Example #1
0
        public async Task CloudQueueAddMessageFullParameterAsync()
        {
            CloudQueueMessage futureMessage  = new CloudQueueMessage("This message is for the future.");
            CloudQueueMessage presentMessage = new CloudQueueMessage("This message is for the present.");

            CloudQueueClient client = GenerateCloudQueueClient();
            CloudQueue       queue  = client.GetQueueReference(GenerateNewQueueName());

            try
            {
                await queue.CreateIfNotExistsAsync();

                await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromDays(2), null, null);

                VerifyAddMessageResult(futureMessage);

                // We should not be able to see the future message yet.
                CloudQueueMessage retrievedMessage = await queue.GetMessageAsync();

                Assert.IsNull(retrievedMessage);

                await queue.AddMessageAsync(presentMessage, null, TimeSpan.Zero, null, null);

                VerifyAddMessageResult(presentMessage);
                await queue.AddMessageAsync(presentMessage, TimeSpan.FromDays(1), null, null, null);

                VerifyAddMessageResult(presentMessage);

                // We should be able to see the present message.
                retrievedMessage = await queue.GetMessageAsync();

                Assert.IsNotNull(retrievedMessage);
                Assert.AreEqual <string>(presentMessage.AsString, retrievedMessage.AsString);

                await queue.AddMessageAsync(futureMessage, TimeSpan.FromDays(2), TimeSpan.FromDays(1), null, null);

                VerifyAddMessageResult(futureMessage);

                await queue.ClearAsync();

                // -1 seconds should set an infinite ttl
                await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(-1), null, null, null);

                retrievedMessage = await queue.PeekMessageAsync();

                Assert.AreEqual(DateTime.MaxValue.Year, retrievedMessage.ExpirationTime.Value.Year);

                // There should be no upper bound on ttl
                await queue.AddMessageAsync(presentMessage, TimeSpan.MaxValue, null, null, null);

                // Check other edge cases
                await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(0), null, null);

                await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(7 * 24 * 60 * 60), TimeSpan.FromSeconds(7 * 24 * 60 * 60 - 1), null, null);

                await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(-1), TimeSpan.FromSeconds(1), null, null);

                await TestHelper.ExpectedExceptionAsync <ArgumentException>(
                    async() => await queue.AddMessageAsync(futureMessage, TimeSpan.FromDays(1), TimeSpan.FromDays(2), null, null),
                    "Using a visibility timeout longer than the time to live should fail");

                await TestHelper.ExpectedExceptionAsync <ArgumentException>(
                    async() => await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromDays(8), null, null),
                    "Using a visibility longer than the maximum visibility timeout should fail");

                await TestHelper.ExpectedExceptionAsync <ArgumentException>(
                    async() => await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromMinutes(-1), null, null),
                    "Using a negative visibility should fail");

                await TestHelper.ExpectedExceptionAsync <ArgumentException>(
                    async() => await queue.AddMessageAsync(futureMessage, TimeSpan.FromMinutes(-1), null, null, null),
                    "Using a negative TTL other than -1 seconds (infinite) should fail");

                await TestHelper.ExpectedExceptionAsync <ArgumentException>(
                    () => queue.AddMessageAsync(futureMessage, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), null, null),
                    "Visibility timeout must be strictly less than the TTL");

                await TestHelper.ExpectedExceptionAsync <ArgumentException>(
                    () => queue.AddMessageAsync(presentMessage, null, CloudQueueMessage.MaxVisibilityTimeout, null, null),
                    "Null TTL will default to 7 days, which is the max visibility timeout. They cannot be equal.");
            }
            finally
            {
                queue.DeleteIfExistsAsync().Wait();
            }
        }
        public void CloudQueueTestCorsMaxHeaders()
        {
            CorsRule ruleManyHeaders = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.xyz.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-target*",
                    "x-ms-meta-other*"
                },
                ExposedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-data*",
                    "x-ms-meta-source*"
                }
            };

            // Add maximum number of non-prefixed headers
            for (int i = 0; i < 64; i++)
            {
                ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-" + i);
                ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-" + i);
            }

            CloudQueueClient client = GenerateCloudQueueClient();

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            });

            // Test with too many Exposed Headers (65)
            ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-toomany");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of 64 literal exposed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.ExposedHeaders.Remove("x-ms-meta-toomany");

            // Test with too many Allowed Headers (65)
            ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-toomany");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of 64 literal allowed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.AllowedHeaders.Remove("x-ms-meta-toomany");

            // Test with too many Exposed Prefixed Headers (three)
            ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-toomany*");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of two prefixed exposed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.ExposedHeaders.Remove("x-ms-meta-toomany*");

            // Test with too many Allowed Prefixed Headers (three)
            ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-toomany*");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of two prefixed allowed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.AllowedHeaders.Remove("x-ms-meta-toomany*");
        }
        public async Task QueueContinuationTokenVerifyXmlWithinXml()
        {
            CloudQueueClient client     = GenerateCloudQueueClient();
            string           prefix     = "dotnetqueuetest" + Guid.NewGuid().ToString("N");
            List <string>    queueNames = new List <string>();
            int count = 30;

            for (int i = 0; i < count; i++)
            {
                queueNames.Add(prefix + i);
                client.GetQueueReference(prefix + i).Create();
            }

            QueueContinuationToken token   = null;
            List <CloudQueue>      results = new List <CloudQueue>();

            do
            {
                QueueResultSegment segment = client.ListQueuesSegmented(prefix, QueueListingDetails.None, 5, token, null, null);
                token = segment.ContinuationToken;
                results.AddRange(segment.Results);
                if (token != null)
                {
                    Assert.AreEqual(null, token.GetSchema());

                    XmlWriterSettings settings = new XmlWriterSettings();
                    settings.Indent = true;
                    StringBuilder sb = new StringBuilder();
                    using (XmlWriter writer = XmlWriter.Create(sb, settings))
                    {
                        writer.WriteStartElement("test1");
                        writer.WriteStartElement("test2");
                        token.WriteXml(writer);
                        writer.WriteEndElement();
                        writer.WriteEndElement();
                    }

                    using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString()))))
                    {
                        token = new QueueContinuationToken();
                        await reader.ReadStartElementAsync();

                        await reader.ReadStartElementAsync();

                        await token.ReadXmlAsync(reader);

                        await reader.ReadEndElementAsync();

                        await reader.ReadEndElementAsync();
                    }
                }
            }while (token != null);

            foreach (CloudQueue queue in results)
            {
                if (queueNames.Remove(queue.Name))
                {
                    queue.Delete();
                }
                else
                {
                    Assert.Fail();
                }
            }

            Assert.AreEqual <int>(0, queueNames.Count);
        }
        public void CloudQueueTestValidCorsRules()
        {
            CorsRule ruleMinRequired = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.xyz.com"
                },
                AllowedMethods = CorsHttpMethods.Get
            };

            CorsRule ruleBasic = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.ab.com", "www.bc.com"
                },
                AllowedMethods  = CorsHttpMethods.Get | CorsHttpMethods.Put,
                MaxAgeInSeconds = 500,
                ExposedHeaders  =
                    new List <string>()
                {
                    "x-ms-meta-data*",
                    "x-ms-meta-source*",
                    "x-ms-meta-abc",
                    "x-ms-meta-bcd"
                },
                AllowedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-data*",
                    "x-ms-meta-target*",
                    "x-ms-meta-xyz",
                    "x-ms-meta-foo"
                }
            };

            CorsRule ruleAllMethods = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.xyz.com"
                },
                AllowedMethods =
                    CorsHttpMethods.Put | CorsHttpMethods.Trace
                    | CorsHttpMethods.Connect | CorsHttpMethods.Delete
                    | CorsHttpMethods.Get | CorsHttpMethods.Head
                    | CorsHttpMethods.Options | CorsHttpMethods.Post
                    | CorsHttpMethods.Merge
            };

            CorsRule ruleSingleExposedHeader = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                ExposedHeaders = new List <string>()
                {
                    "x-ms-meta-bcd"
                },
            };

            CorsRule ruleSingleExposedPrefixHeader = new CorsRule()
            {
                AllowedOrigins =
                    new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                ExposedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-data*"
                },
            };

            CorsRule ruleSingleAllowedHeader = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders = new List <string>()
                {
                    "x-ms-meta-xyz",
                },
            };

            CorsRule ruleSingleAllowedPrefixHeader = new CorsRule()
            {
                AllowedOrigins =
                    new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-target*"
                },
            };

            CorsRule ruleAllowAll = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "*"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders = new List <string>()
                {
                    "*"
                },
                ExposedHeaders = new List <string>()
                {
                    "*"
                }
            };

            CloudQueueClient client = GenerateCloudQueueClient();

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleBasic
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleMinRequired
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleAllMethods
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleExposedHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleExposedPrefixHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleAllowedHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleAllowedPrefixHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleAllowAll
            });

            // Empty rule set should delete all rules
            this.TestCorsRules(client, new List <CorsRule>()
            {
            });

            // Test duplicate rules
            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleBasic, ruleBasic
            });

            // Test max number of  rules (five)
            this.TestCorsRules(
                client,
                new List <CorsRule>()
            {
                ruleBasic,
                ruleMinRequired,
                ruleAllMethods,
                ruleSingleExposedHeader,
                ruleSingleExposedPrefixHeader
            });


            // Test max number of rules + 1 (six)
            TestHelper.ExpectedException(
                () =>
                this.TestCorsRules(
                    client,
                    new List <CorsRule>()
            {
                ruleBasic,
                ruleMinRequired,
                ruleAllMethods,
                ruleSingleExposedHeader,
                ruleSingleExposedPrefixHeader,
                ruleSingleAllowedHeader
            }),
                "Services are limited to a maximum of five CORS rules.",
                HttpStatusCode.BadRequest,
                "InvalidXmlDocument");
        }
Example #5
0
        internal static QueueRequestOptions ApplyDefaults(QueueRequestOptions options, CloudQueueClient serviceClient)
        {
            QueueRequestOptions modifiedOptions = new QueueRequestOptions(options);

            modifiedOptions.RetryPolicy =
                modifiedOptions.RetryPolicy
                ?? serviceClient.DefaultRequestOptions.RetryPolicy
                ?? BaseDefaultRequestOptions.RetryPolicy;

#if !(WINDOWS_RT || NETCORE)
            modifiedOptions.EncryptionPolicy =
                modifiedOptions.EncryptionPolicy
                ?? serviceClient.DefaultRequestOptions.EncryptionPolicy
                ?? BaseDefaultRequestOptions.EncryptionPolicy;

            modifiedOptions.RequireEncryption =
                modifiedOptions.RequireEncryption
                ?? serviceClient.DefaultRequestOptions.RequireEncryption
                ?? BaseDefaultRequestOptions.RequireEncryption;
#endif

            modifiedOptions.LocationMode =
                modifiedOptions.LocationMode
                ?? serviceClient.DefaultRequestOptions.LocationMode
                ?? BaseDefaultRequestOptions.LocationMode;

            modifiedOptions.ServerTimeout =
                modifiedOptions.ServerTimeout
                ?? serviceClient.DefaultRequestOptions.ServerTimeout
                ?? BaseDefaultRequestOptions.ServerTimeout;

            modifiedOptions.MaximumExecutionTime =
                modifiedOptions.MaximumExecutionTime
                ?? serviceClient.DefaultRequestOptions.MaximumExecutionTime
                ?? BaseDefaultRequestOptions.MaximumExecutionTime;

            if (!modifiedOptions.OperationExpiryTime.HasValue && modifiedOptions.MaximumExecutionTime.HasValue)
            {
                modifiedOptions.OperationExpiryTime = DateTime.Now + modifiedOptions.MaximumExecutionTime.Value;
            }

            return(modifiedOptions);
        }
        public void CloudQueueMessageEncryptionWithStrictMode()
        {
            // Create the Key to be used for wrapping.
            SymmetricKey aesKey = new SymmetricKey("symencryptionkey");

            // Create the resolver to be used for unwrapping.
            DictionaryKeyResolver resolver = new DictionaryKeyResolver();

            resolver.Add(aesKey);

            CloudQueueClient client = GenerateCloudQueueClient();
            string           name   = GenerateNewQueueName();
            CloudQueue       queue  = client.GetQueueReference(name);

            try
            {
                queue.CreateIfNotExists();

                string            messageStr = Guid.NewGuid().ToString();
                CloudQueueMessage message    = new CloudQueueMessage(messageStr);

                QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);

                // Add message with policy.
                QueueRequestOptions createOptions = new QueueRequestOptions()
                {
                    EncryptionPolicy = policy
                };
                createOptions.RequireEncryption = true;

                queue.AddMessage(message, null, null, createOptions, null);

                // Set policy to null and add message while RequireEncryption flag is still set to true. This should throw.
                createOptions.EncryptionPolicy = null;

                TestHelper.ExpectedException <InvalidOperationException>(
                    () => queue.AddMessage(message, null, null, createOptions, null),
                    "Not specifying a policy when RequireEnryption is set to true should throw.");

                // Retrieve message
                QueueEncryptionPolicy retrPolicy      = new QueueEncryptionPolicy(null, resolver);
                QueueRequestOptions   retrieveOptions = new QueueRequestOptions()
                {
                    EncryptionPolicy = retrPolicy
                };
                retrieveOptions.RequireEncryption = true;

                CloudQueueMessage retrMessage = queue.GetMessage(null, retrieveOptions, null);

                // Update message with plain text.
                string updatedMessage = Guid.NewGuid().ToString("N");
                retrMessage.SetMessageContent(updatedMessage);

                queue.UpdateMessage(retrMessage, TimeSpan.FromSeconds(0), MessageUpdateFields.Content | MessageUpdateFields.Visibility);

                // Retrieve updated message with RequireEncryption flag but no metadata on the service. This should throw.
                TestHelper.ExpectedException <StorageException>(
                    () => queue.GetMessage(null, retrieveOptions, null),
                    "Retrieving with RequireEncryption set to true and no metadata on the service should fail.");

                // Set RequireEncryption to false and retrieve.
                retrieveOptions.RequireEncryption = false;
                queue.GetMessage(null, retrieveOptions, null);
            }
            finally
            {
                queue.DeleteIfExists();
            }
        }
        public async Task QueueRegionalSASTestAsync()
        {
#if NETCORE
            //CultureInfo currentCulture = CultureInfo.CurrentCulture;
            //CultureInfo.CurrentCulture = new CultureInfo("it");
#else
            string currentPrimaryLanguage = ApplicationLanguages.PrimaryLanguageOverride;
            ApplicationLanguages.PrimaryLanguageOverride = "it";
#endif

            CloudQueueClient client = GenerateCloudQueueClient();
            CloudQueue       queue  = client.GetQueueReference(GenerateNewQueueName());

            try
            {
                await queue.CreateAsync();

                string            messageContent = Guid.NewGuid().ToString();
                CloudQueueMessage message        = new CloudQueueMessage(messageContent);
                await queue.AddMessageAsync(message);

                // Prepare SAS authentication with full permissions
                string                       id          = Guid.NewGuid().ToString();
                DateTime                     start       = DateTime.UtcNow;
                DateTime                     expiry      = start.AddMinutes(30);
                QueuePermissions             permissions = new QueuePermissions();
                SharedAccessQueuePermissions queuePerm   = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
                permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
                {
                    SharedAccessStartTime  = start,
                    SharedAccessExpiryTime = expiry,
                    Permissions            = queuePerm
                });

                await queue.SetPermissionsAsync(permissions);

                await Task.Delay(30 * 1000);

                string             sasTokenFromId   = queue.GetSharedAccessSignature(null, id);
                StorageCredentials sasCredsFromId   = new StorageCredentials(sasTokenFromId);
                CloudQueue         sasQueueFromId   = new CloudQueue(queue.Uri, sasCredsFromId);
                CloudQueueMessage  receivedMessage1 = await sasQueueFromId.PeekMessageAsync();

                Assert.AreEqual(messageContent, receivedMessage1.AsString);

                string             sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null);
                StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy);
                CloudQueue         sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy);
                CloudQueueMessage  receivedMessage2   = await sasQueueFromPolicy.PeekMessageAsync();

                Assert.AreEqual(messageContent, receivedMessage2.AsString);
            }
            finally
            {
#if NETCORE
                //CultureInfo.CurrentCulture = currentCulture;
#else
                ApplicationLanguages.PrimaryLanguageOverride = currentPrimaryLanguage;
#endif
                queue.DeleteAsync().Wait();
            }
        }
 public static void MyClassInitialize(TestContext testContext)
 {
     client          = GenerateCloudQueueClient();
     startProperties = client.GetServicePropertiesAsync().Result;
 }