public async Task KinesisCRUD() { var streamName = UtilityMethods.GenerateName("KinesisCRUD"); // Create a stream. await Client.CreateStreamAsync(new CreateStreamRequest { ShardCount = 1, StreamName = streamName }); _streamNames.Add(streamName); // Describe the stream. var stream = (await Client.DescribeStreamAsync(new DescribeStreamRequest { StreamName = streamName })).StreamDescription; Assert.Equal(stream.HasMoreShards, false); Assert.False(string.IsNullOrEmpty(stream.StreamARN)); Assert.Equal(stream.StreamName, streamName); Assert.True(stream.StreamStatus == StreamStatus.CREATING || stream.StreamStatus == StreamStatus.ACTIVE); // List streams. var streamNames = (await Client.ListStreamsAsync()).StreamNames; Assert.True(streamNames.Count > 0); Assert.True(streamNames.Contains(streamName)); }
public async void TestMultipleQueueSubscription() { var topicName1 = UtilityMethods.GenerateName("TestMultipleQueueSubscription"); var topic = await Client.CreateTopicAsync(topicName1); _topicArns.Add(topic.TopicArn); var topicName2 = UtilityMethods.GenerateName("TestMultipleQueueSubscription2"); var response = await Client.CreateTopicAsync(topicName2); _topicArns.Add(response.TopicArn); var queueName = UtilityMethods.GenerateName("TestMultipleQueueSubscription"); var queueUrl = (await sqsClient.CreateQueueAsync(queueName)).QueueUrl; _queueUrl.Add(queueUrl); ICoreAmazonSQS coreSqs = sqsClient as ICoreAmazonSQS; var topics = await Client.SubscribeQueueToTopicsAsync(_topicArns, coreSqs, queueUrl); var subscriptionArns = topics.Values; Assert.Equal(2, subscriptionArns.Count); Thread.Sleep(TimeSpan.FromSeconds(5)); var attributes = (await sqsClient.GetQueueAttributesAsync(queueUrl, new List <string> { "All" })).Attributes; var policy = Policy.FromJson(attributes["Policy"]); Assert.Equal(2, policy.Statements.Count); }
public async Task SetTopicConfigurationTests() { using (var snsClient = new AmazonSimpleNotificationServiceClient()) { string topicName = UtilityMethods.GenerateName("events-test"); var snsCreateResponse = await snsClient.CreateTopicAsync(topicName); var bucketName = await UtilityMethods.CreateBucketAsync(Client, "SetTopicConfigurationTests"); try { await snsClient.AuthorizeS3ToPublishAsync(snsCreateResponse.TopicArn, bucketName); PutBucketNotificationRequest putRequest = new PutBucketNotificationRequest { BucketName = bucketName, TopicConfigurations = new List <TopicConfiguration> { new TopicConfiguration { Id = "the-topic-test", Topic = snsCreateResponse.TopicArn, Events = new List <EventType> { EventType.ObjectCreatedPut } } } }; await Client.PutBucketNotificationAsync(putRequest); var getResponse = WaitUtils.WaitForComplete( () => { return(Client.GetBucketNotificationAsync(bucketName).Result); }, (r) => { return(r.TopicConfigurations.Count > 0); }); Assert.Equal(1, getResponse.TopicConfigurations.Count); Assert.Equal(1, getResponse.TopicConfigurations[0].Events.Count); Assert.Equal(EventType.ObjectCreatedPut, getResponse.TopicConfigurations[0].Events[0]); #pragma warning disable 618 Assert.Equal("s3:ObjectCreated:Put", getResponse.TopicConfigurations[0].Event); #pragma warning restore 618 Assert.Equal("the-topic-test", getResponse.TopicConfigurations[0].Id); Assert.Equal(snsCreateResponse.TopicArn, getResponse.TopicConfigurations[0].Topic); } finally { await snsClient.DeleteTopicAsync(snsCreateResponse.TopicArn); await UtilityMethods.DeleteBucketWithObjectsAsync(Client, bucketName); } } }
public async Task TestDeleteApplication() { var appName = UtilityMethods.GenerateName(); await Client.CreateApplicationAsync(new CreateApplicationRequest { ApplicationName = appName }); Assert.True(Client.ListApplicationsAsync().Result.Applications.Contains(appName)); await Client.DeleteApplicationAsync(new DeleteApplicationRequest { ApplicationName = appName }); Assert.False(Client.ListApplicationsAsync().Result.Applications.Contains(appName)); }
private async Task <string> CreateQueue() { var queueName = UtilityMethods.GenerateName("TestQueueSubscription"); var queueUrl = (await sqsClient.CreateQueueAsync(new CreateQueueRequest { QueueName = queueName })).QueueUrl; _queueUrl.Add(queueUrl); return(queueUrl); }
private async Task <string> CreateTopic() { // create new topic var topicName = UtilityMethods.GenerateName("TestQueueSubscription"); var createTopicRequest = new CreateTopicRequest { Name = topicName }; var createTopicResult = await Client.CreateTopicAsync(createTopicRequest); var topicArn = createTopicResult.TopicArn; _topicArns.Add(topicArn); return(topicArn); }
public async Task TestGetQueueUrl() { string queueName = UtilityMethods.GenerateName("TestGetQueueUrl"); CreateQueueResponse createResponse = await Client.CreateQueueAsync(new CreateQueueRequest() { QueueName = queueName }); _queueUrls.Add(createResponse.QueueUrl); GetQueueUrlRequest request = new GetQueueUrlRequest() { QueueName = queueName }; GetQueueUrlResponse response = await Client.GetQueueUrlAsync(request); Assert.Equal(createResponse.QueueUrl, response.QueueUrl); }
public async Task SimpleSend() { int maxMessageLength = 20 * 1024; string queueName = UtilityMethods.GenerateName("SimpleSend"); string queueURL = await createQueueTest(queueName); StringBuilder sb = new StringBuilder("The quick brown fox jumped over the lazy dog"); string messageBody = sb.ToString(); if (messageBody.Length > maxMessageLength) { messageBody = messageBody.Substring(0, maxMessageLength); } await TestSendMessage(Client, queueURL, messageBody); await TestSendMessageBatch(Client, queueURL, messageBody); await TestReceiveMessage(Client, queueURL); }
public async Task FindTopic() { // create new topic var name = UtilityMethods.GenerateName("FindTopic"); var createTopicRequest = new CreateTopicRequest { Name = name }; var createTopicResult = await Client.CreateTopicAsync(createTopicRequest); var topicArn = createTopicResult.TopicArn; _topicArns.Add(topicArn); var foundTopic = await Client.FindTopicAsync(name); // verify that the topic was fund Assert.NotNull(foundTopic); }
public async Task CRUDTopics() { // list all topics var allTopics = await GetAllTopics(); // create new topic var name = UtilityMethods.GenerateName("CrudTopics"); var createTopicRequest = new CreateTopicRequest { Name = name }; var createTopicResult = await Client.CreateTopicAsync(createTopicRequest); var topicArn = createTopicResult.TopicArn; _topicArns.Add(topicArn); // verify there is a new topic allTopics = await GetAllTopics(); Assert.True(allTopics.Exists(t => t.TopicArn.Contains(name))); // set topic attribute var setTopicAttributesRequest = new SetTopicAttributesRequest { TopicArn = topicArn, AttributeName = "DisplayName", AttributeValue = "Test topic" }; await Client.SetTopicAttributesAsync(setTopicAttributesRequest); // verify topic attributes var getTopicAttributesRequest = new GetTopicAttributesRequest { TopicArn = topicArn }; var topicAttributes = (await Client.GetTopicAttributesAsync(getTopicAttributesRequest)).Attributes; Assert.Equal(setTopicAttributesRequest.AttributeValue, topicAttributes[setTopicAttributesRequest.AttributeName]); }
public async Task ListGlacierCalls() { string vaultName = UtilityMethods.GenerateName("glacier-test"); Client.CreateVaultAsync(new CreateVaultRequest { VaultName = vaultName }).Wait(); try { Assert.NotNull(await Client.ListJobsAsync(new ListJobsRequest { VaultName = vaultName }).ConfigureAwait(false)); Assert.NotNull(await Client.ListMultipartUploadsAsync(new Glacier.Model.ListMultipartUploadsRequest { VaultName = vaultName }).ConfigureAwait(false)); Assert.NotNull(await Client.ListVaultsAsync(new ListVaultsRequest()).ConfigureAwait(false)); } finally { await Client.DeleteVaultAsync(new DeleteVaultRequest { VaultName = vaultName }); } }
public async Task AuthorizeS3ToSendMessageAsyncTest() { string bucketName = UtilityMethods.GenerateName("AuthorizeS3ToSendMessageAsync"); string mainQueueName = UtilityMethods.GenerateName("AuthorizeS3ToSendMessageAsync"); string mainQueueURL = await createQueueTest(mainQueueName); string s3ObjectKey = UtilityMethods.GenerateName("key"); Assert.False(String.Compare(mainQueueURL, "fail") == 0, "Failed to create an SQS queue"); using (var s3Client = new AmazonS3Client(s3ClientConfig)) { var bucketResponse = await s3Client.PutBucketAsync(new PutBucketRequest { BucketName = bucketName }); _bucketNames.Add(bucketName); Assert.True(await hasS3Bucket(s3Client, bucketName), "Failed to create an S3 bucket"); var arn = await Client.AuthorizeS3ToSendMessageAsync(mainQueueURL, bucketName); await s3Client.PutBucketNotificationAsync(new PutBucketNotificationRequest { BucketName = bucketName, QueueConfigurations = new List <QueueConfiguration> { new QueueConfiguration { Queue = arn, Events = new List <EventType> { EventType.ObjectCreatedAll } } }, }); var count = (await Client.ReceiveMessageAsync(mainQueueURL)).Messages.Count; await s3Client.PutObjectAsync(new PutObjectRequest { ContentBody = "Hello World", BucketName = bucketName, Key = s3ObjectKey, }); Assert.True(await hasS3Object(s3Client, bucketName, s3ObjectKey), "Failed to put an S3 object"); bool objectCreaedMessageReceived = false; for (int i = 0; i < 5; i++) { var messages = (await Client.ReceiveMessageAsync(mainQueueURL)).Messages; foreach (var message in messages) { objectCreaedMessageReceived = message.Body.Contains("ObjectCreated:Put"); if (objectCreaedMessageReceived) { return; } } UtilityMethods.Sleep(TimeSpan.FromSeconds(2)); } Assert.True(objectCreaedMessageReceived, "Failed to receive object creaed message."); } }
public async Task SetQueueConfigurationTests() { var filterRule = new FilterRule("Prefix", "test/"); using (var sqsClient = new AmazonSQSClient()) { string topicName = UtilityMethods.GenerateName("events-test"); var createResponse = await sqsClient.CreateQueueAsync(topicName); var bucketName = await UtilityMethods.CreateBucketAsync(Client, "SetQueueConfigurationTests"); try { var queueArn = await sqsClient.AuthorizeS3ToSendMessageAsync(createResponse.QueueUrl, bucketName); PutBucketNotificationRequest putRequest = new PutBucketNotificationRequest { BucketName = bucketName, QueueConfigurations = new List <QueueConfiguration> { new QueueConfiguration { Id = "the-queue-test", Queue = queueArn, Events = { EventType.ObjectCreatedPut }, Filter = new Filter { S3KeyFilter = new S3KeyFilter { FilterRules = new List <FilterRule> { filterRule } } } } } }; await Client.PutBucketNotificationAsync(putRequest); var getResponse = await Client.GetBucketNotificationAsync(bucketName); Assert.Equal(1, getResponse.QueueConfigurations.Count); Assert.Equal(1, getResponse.QueueConfigurations[0].Events.Count); Assert.Equal(EventType.ObjectCreatedPut, getResponse.QueueConfigurations[0].Events[0]); Assert.NotNull(getResponse.QueueConfigurations[0].Filter); Assert.NotNull(getResponse.QueueConfigurations[0].Filter.S3KeyFilter); Assert.NotNull(getResponse.QueueConfigurations[0].Filter.S3KeyFilter.FilterRules); Assert.Equal(1, getResponse.QueueConfigurations[0].Filter.S3KeyFilter.FilterRules.Count); Assert.Equal(filterRule.Name, getResponse.QueueConfigurations[0].Filter.S3KeyFilter.FilterRules[0].Name); Assert.Equal(filterRule.Value, getResponse.QueueConfigurations[0].Filter.S3KeyFilter.FilterRules[0].Value); Assert.Equal("the-queue-test", getResponse.QueueConfigurations[0].Id); Assert.Equal(queueArn, getResponse.QueueConfigurations[0].Queue); // Purge queue to remove test message sent configuration was setup. await sqsClient.PurgeQueueAsync(createResponse.QueueUrl); Thread.Sleep(TimeSpan.FromSeconds(1)); var putObjectRequest = new PutObjectRequest { BucketName = bucketName, Key = "test/data.txt", ContentBody = "Important Data" }; await Client.PutObjectAsync(putObjectRequest); string messageBody = null; for (int i = 0; i < 5 && messageBody == null; i++) { var receiveResponse = await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest { QueueUrl = createResponse.QueueUrl, WaitTimeSeconds = 20 }); if (receiveResponse.Messages.Count != 0) { messageBody = receiveResponse.Messages[0].Body; } } var evnt = S3EventNotification.ParseJson(messageBody); Assert.Equal(1, evnt.Records.Count); Assert.Equal(putObjectRequest.BucketName, evnt.Records[0].S3.Bucket.Name); Assert.Equal(putObjectRequest.Key, evnt.Records[0].S3.Object.Key); Assert.Equal(putObjectRequest.ContentBody.Length, evnt.Records[0].S3.Object.Size); } finally { await sqsClient.DeleteQueueAsync(createResponse.QueueUrl); await UtilityMethods.DeleteBucketWithObjectsAsync(Client, bucketName); } } }
public async void TestQueueSubscription() { // create new topic var topicName = UtilityMethods.GenerateName("TestQueueSubscription"); var createTopicRequest = new CreateTopicRequest { Name = topicName }; var createTopicResult = await Client.CreateTopicAsync(createTopicRequest); var topicArn = createTopicResult.TopicArn; _topicArns.Add(topicArn); var queueName = UtilityMethods.GenerateName("TestQueueSubscription"); var queueUrl = (await sqsClient.CreateQueueAsync(new CreateQueueRequest { QueueName = queueName })).QueueUrl; _queueUrl.Add(queueUrl); ICoreAmazonSQS coreSqs = sqsClient as ICoreAmazonSQS; var subscriptionARN = await Client.SubscribeQueueAsync(topicArn, coreSqs, queueUrl); // Sleep to wait for the subscribe to complete. Thread.Sleep(TimeSpan.FromSeconds(5)); var publishRequest = new PublishRequest { TopicArn = topicArn, Subject = "Test Subject", Message = "Test Message", MessageAttributes = new Dictionary <string, SNSMessageAttributeValue> { { "Color", new SNSMessageAttributeValue { StringValue = "Red", DataType = "String" } }, { "Binary", new SNSMessageAttributeValue { DataType = "Binary", BinaryValue = new MemoryStream(Encoding.UTF8.GetBytes("Yes please")) } }, { "Prime", new SNSMessageAttributeValue { StringValue = "31", DataType = "Number" } }, } }; await Client.PublishAsync(publishRequest); var messages = (await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest { QueueUrl = queueUrl, WaitTimeSeconds = 20 })).Messages; Assert.Equal(1, messages.Count); var message = messages[0]; string bodyJson; // Handle some accounts returning message body as base 64 encoded. if (message.Body.Trim()[0] == '{') { bodyJson = message.Body; } else { bodyJson = Encoding.UTF8.GetString(Convert.FromBase64String(message.Body)); } var json = ThirdParty.Json.LitJson.JsonMapper.ToObject(bodyJson); var messageText = json["Message"]; var messageSubject = json["Subject"]; Assert.Equal(publishRequest.Message, messageText.ToString()); Assert.Equal(publishRequest.Subject, messageSubject.ToString()); var messageAttributes = json["MessageAttributes"]; Assert.Equal(publishRequest.MessageAttributes.Count, messageAttributes.Count); foreach (var ma in publishRequest.MessageAttributes) { var name = ma.Key; var value = ma.Value; Assert.True(messageAttributes.PropertyNames.Contains(name, StringComparer.Ordinal)); var jsonAttribute = messageAttributes[name]; var jsonType = jsonAttribute["Type"].ToString(); var jsonValue = jsonAttribute["Value"].ToString(); Assert.NotNull(jsonType); Assert.NotNull(jsonValue); Assert.Equal(value.DataType, jsonType); Assert.Equal(value.DataType != "Binary" ? value.StringValue : Convert.ToBase64String(value.BinaryValue.ToArray()), jsonValue); } await sqsClient.DeleteMessageAsync(new DeleteMessageRequest { QueueUrl = queueUrl, ReceiptHandle = messages[0].ReceiptHandle }); // This will unsubscribe but leave the policy in place. await Client.UnsubscribeAsync(new UnsubscribeRequest { SubscriptionArn = subscriptionARN }); // Subscribe again to see if this affects the policy. await Client.SubscribeQueueAsync(topicArn, coreSqs, queueUrl); await Client.PublishAsync(new PublishRequest { TopicArn = topicArn, Message = "Test Message again" }); messages = (await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest { QueueUrl = queueUrl, WaitTimeSeconds = 20 })).Messages; Assert.Equal(1, messages.Count); var response = WaitUtils.WaitForComplete( () => { return(sqsClient.GetQueueAttributesAsync(new GetQueueAttributesRequest { AttributeNames = new List <string> { "All" }, QueueUrl = queueUrl }).Result); }, (r) => { return(!string.IsNullOrEmpty(r.Policy)); }); var policy = Policy.FromJson(response.Policy); Assert.Equal(1, policy.Statements.Count); }
public async Task SubscribeTopic() { const string emailAddress = "*****@*****.**"; var subscriptionWaitDelay = TimeSpan.FromMinutes(2); // create new topic var name = UtilityMethods.GenerateName("SubscribeTopic"); var createTopicRequest = new CreateTopicRequest { Name = name }; var createTopicResult = await Client.CreateTopicAsync(createTopicRequest); var topicArn = createTopicResult.TopicArn; _topicArns.Add(topicArn); // subscribe an email address to the topic var subscribeRequest = new SubscribeRequest { Protocol = "email", Endpoint = emailAddress, TopicArn = topicArn }; await Client.SubscribeAsync(subscribeRequest); // wait until subscription has been confirmed, maximum wait time of two minutes // by default string subArn = null; var latest = DateTime.Now + subscriptionWaitDelay; while (DateTime.Now < latest) { // get subscriptions for topic var listSubscriptionsRequest = new ListSubscriptionsByTopicRequest { TopicArn = topicArn }; var subs = (await Client.ListSubscriptionsByTopicAsync(listSubscriptionsRequest)).Subscriptions; Assert.Equal(1, subs.Count); // test whether the subscription has been confirmed var subscription = subs[0]; if (!string.Equals(subscription.SubscriptionArn, "PendingConfirmation", StringComparison.Ordinal)) { subArn = subscription.SubscriptionArn; break; } // wait UtilityMethods.Sleep(TimeSpan.FromSeconds(15)); } // verify that the subscription was confirmed and the arn has been set Assert.NotNull(subArn); // publish a message to the topic await Client.PublishAsync(new PublishRequest { TopicArn = topicArn, Subject = "Test subject", Message = "Test message" }); // delete the subscription await Client.UnsubscribeAsync(new UnsubscribeRequest { SubscriptionArn = subArn }); }