public static void SetSerivceProperties(Constants.ServiceType serviceType, Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties)
{
switch (serviceType)
{
case Constants.ServiceType.Blob:
StorageAccount.CreateCloudBlobClient().SetServiceProperties(serviceProperties);
break;
case Constants.ServiceType.Queue:
StorageAccount.CreateCloudQueueClient().SetServiceProperties(serviceProperties);
break;
case Constants.ServiceType.Table:
StorageAccount.CreateCloudTableClient().SetServiceProperties(serviceProperties);
break;
case Constants.ServiceType.File:
FileServiceProperties fileProperties = new FileServiceProperties();
fileProperties.Cors = serviceProperties.Cors;
fileProperties.HourMetrics = serviceProperties.HourMetrics;
fileProperties.MinuteMetrics = serviceProperties.MinuteMetrics;
StorageAccount.CreateCloudFileClient().SetServiceProperties(fileProperties);
break;
}
}
public void RemoveCORSRuleWithInvalidCredential()
{
Constants.ServiceType serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.RemoveAzureStorageCORSRules(serviceType), "Remove CORS rules with invalid credential should fail.");
CheckErrorMessage();
}
public void SetCORSRuleWithInvalidCredential()
{
Constants.ServiceType serviceType = GetRandomServiceType();
var corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5));
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set CORS rules with invalid credential should fail.");
CheckErrorMessage();
}
public void SetServiceProperties_InvalidDefaultServiceVersion_Blob()
{
Constants.ServiceType service = Constants.ServiceType.Blob;
string DefaultServiceVersion = "2016-01-02";
Test.Assert(!CommandAgent.UpdateAzureStorageServiceProperties(service, DefaultServiceVersion), "SetAzureStorageServiceProperties with service {0} defaultserviceversion {1} should fail.", service, DefaultServiceVersion);
ExpectedContainErrorMessage("XML specified is not syntactically valid.");
}
public void ChangeCORSRules()
{
Constants.ServiceType serviceType = GetRandomServiceType();
try
{
PSCorsRule[] corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5));
Test.Assert(CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules),
"Set cors rule to {0} service should succeed", serviceType);
Test.Assert(CommandAgent.GetAzureStorageCORSRules(serviceType),
"Get CORS rule of {0} service should succeed.", serviceType);
PSCorsRule[] newCorsRules = GetCORSRules();
CORSRuleUtil.ValidateCORSRules(corsRules, newCorsRules);
foreach (var corsRule in newCorsRules)
{
switch (random.Next(0, 5))
{
case 0:
corsRule.AllowedHeaders = CORSRuleUtil.GetRandomHeaders();
break;
case 1:
corsRule.AllowedMethods = CORSRuleUtil.GetRandomMethods();
break;
case 2:
corsRule.AllowedOrigins = CORSRuleUtil.GetRandomOrigins();
break;
case 3:
corsRule.ExposedHeaders = CORSRuleUtil.GetRandomHeaders();
break;
case 4:
corsRule.MaxAgeInSeconds = random.Next(1, 1000);
break;
}
}
Test.Assert(CommandAgent.SetAzureStorageCORSRules(serviceType, newCorsRules),
"Set cors rule to {0} service should succeed", serviceType);
Test.Assert(CommandAgent.GetAzureStorageCORSRules(serviceType),
"Set cors rule of {0} service should succeed", serviceType);
PSCorsRule[] actualCORSRules = GetCORSRules();
CORSRuleUtil.ValidateCORSRules(newCorsRules, actualCORSRules);
}
finally
{
ClearCorsRules(serviceType);
}
}
public static void ClearCorsRules(Constants.ServiceType serviceType)
{
Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties = new Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties();
serviceProperties.Clean();
serviceProperties.Cors = new CorsProperties();
serviceProperties.Cors.CorsRules.Clear();
SetSerivceProperties(serviceType, serviceProperties);
}
public void SetGetServiceProperties_DefaultServiceVersion_File_Neg()
{
Constants.ServiceType service = Constants.ServiceType.File;
string DefaultServiceVersion = "2016-05-31";
Test.Assert(CommandAgent.UpdateAzureStorageServiceProperties(service, DefaultServiceVersion), "SetAzureStorageServiceProperties with service {0} defaultserviceversion {1} should success.", service, DefaultServiceVersion);
PSSeriviceProperties properties = GetServicePropertiesFromPSH(service);
ExpectNotEqual(DefaultServiceVersion, properties.DefaultServiceVersion, "DefaultServiceVersion");
}
private void ValidateRemoveCORSRule(Constants.ServiceType serviceType)
{
Test.Assert(CommandAgent.RemoveAzureStorageCORSRules(serviceType), "Remove CORS rules of {0} service should succeed.", serviceType);
Test.Assert(CommandAgent.GetAzureStorageCORSRules(serviceType), "Get CORS rules of {0} service should succeed.", serviceType);
PSCorsRule[] actualCORSRule = GetCORSRules();
Test.Assert(0 == actualCORSRule.Length, "There should be 0 CORS rule after removing. Actually there are {0} CORS rule(s)", actualCORSRule.Length);
}
public void Set0CORSRuleTest()
{
PSCorsRule[] corsRules = new PSCorsRule[0];
Constants.ServiceType serviceType = GetRandomServiceType();
if (lang == Language.PowerShell)
{
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set 0 cors rule to {0} service should fail", serviceType);
ExpectedContainErrorMessage("Cannot bind argument to parameter 'CorsRules' because it is an empty array.");
}
else
{
Test.Assert(CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set 0 cors rule to {0} service should succeed", serviceType);
}
}
public void RemoveCORSRulesTest()
{
// No CORS rule exist
Constants.ServiceType serviceType = GetRandomServiceType();
ClearCorsRules(serviceType);
this.ValidateRemoveCORSRule(serviceType);
// Set CORS rules with cmdlet
serviceType = GetRandomServiceType();
PSCorsRule[] corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5));
Test.Assert(CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules),
"Set CORS rules to {0} service should succeed.", serviceType);
this.ValidateRemoveCORSRule(serviceType);
}
private void ValidateCORSRuleSetGet(PSCorsRule[] corsRules)
{
Constants.ServiceType serviceType = GetRandomServiceType();
try
{
Test.Assert(CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set cors rule to {0} service should succeed", serviceType);
Test.Assert(CommandAgent.GetAzureStorageCORSRules(serviceType), "Get CORS rules of {0} service should succeed", serviceType);
CORSRuleUtil.ValidateCORSRules(corsRules, GetCORSRules());
}
finally
{
ClearCorsRules(serviceType);
}
}
private void OverwriteCORSRules(Action <Constants.ServiceType> setCORSRules, Constants.ServiceType serviceType)
{
try
{
setCORSRules(serviceType);
PSCorsRule[] newCorsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5));
Test.Assert(CommandAgent.SetAzureStorageCORSRules(serviceType, newCorsRules),
"Set cors rule to blob service should succeed");
Test.Assert(CommandAgent.GetAzureStorageCORSRules(serviceType),
"Get cors rules of blob service should succeed.");
PSCorsRule[] acturalRules = GetCORSRules();
CORSRuleUtil.ValidateCORSRules(newCorsRules, acturalRules);
}
finally
{
ClearCorsRules(serviceType);
}
}
public abstract bool UpdateAzureStorageServiceProperties(Constants.ServiceType serviceType, string DefaultServiceVersion);
public abstract bool GetAzureStorageServiceProperties(Constants.ServiceType serviceType);
public abstract bool RemoveAzureStorageCORSRules(Constants.ServiceType serviceType);
public abstract bool SetAzureStorageCORSRules(Constants.ServiceType serviceType, PSCorsRule[] corsRules);
public virtual bool SetAzureStorageServiceMetrics(Constants.ServiceType serviceType, Constants.MetricsType metricsType, string metricsLevel = "", string metricsRetentionDays = "",
string metricsVersion = "", bool passThru = false)
{
return(false);
}
public virtual bool SetAzureStorageServiceLogging(Constants.ServiceType serviceType, LoggingOperations[] loggingOperations, string loggingRetentionDays = "",
string loggingVersion = "", bool passThru = false)
{
return(false);
}
public virtual bool GetAzureStorageServiceMetrics(Constants.ServiceType serviceType, Constants.MetricsType metricsType)
{
return(false);
}
///-------------------------------------
/// Logging & Metrics APIs
///-------------------------------------
public virtual bool GetAzureStorageServiceLogging(Constants.ServiceType serviceType)
{
return(false);
}
private PSSeriviceProperties GetServicePropertiesFromPSH(Constants.ServiceType service)
{
Test.Assert(CommandAgent.GetAzureStorageServiceProperties(service), "GetAzureStorageServiceProperties with service as {0} should success.", service);
return(CommandAgent.Output[0][PowerShellAgent.BaseObject] as PSSeriviceProperties);
}
public void GetServiceProperties_AllService_AllProperties()
{
//prepare the service properties to set and get
PSCorsRule[] corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5));
Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties = new Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties();
serviceProperties.Clean();
serviceProperties.Cors = new CorsProperties();
foreach (var rule in corsRules)
{
CorsRule corsRule = new CorsRule()
{
AllowedHeaders = rule.AllowedHeaders,
AllowedOrigins = rule.AllowedOrigins,
ExposedHeaders = rule.ExposedHeaders,
MaxAgeInSeconds = rule.MaxAgeInSeconds,
};
SetAllowedMethods(corsRule, rule.AllowedMethods);
serviceProperties.Cors.CorsRules.Add(corsRule);
}
serviceProperties.HourMetrics = new MetricsProperties("1.0");
serviceProperties.HourMetrics.MetricsLevel = MetricsLevel.ServiceAndApi;
serviceProperties.HourMetrics.RetentionDays = 1;
serviceProperties.MinuteMetrics = new MetricsProperties("1.0");
serviceProperties.MinuteMetrics.MetricsLevel = MetricsLevel.Service;
serviceProperties.MinuteMetrics.RetentionDays = 3;
serviceProperties.Logging = new LoggingProperties("1.0");
serviceProperties.Logging.LoggingOperations = LoggingOperations.All;
serviceProperties.Logging.RetentionDays = 5;
foreach (string servicetype in ValidServiceType)
{
Constants.ServiceType service = Constants.ServiceType.Blob;
Enum.TryParse <Constants.ServiceType>(servicetype, true, out service);
if (service == Constants.ServiceType.Blob) //only Blob support default service version
{
serviceProperties.DefaultServiceVersion = "2017-04-17";
serviceProperties.DeleteRetentionPolicy = new DeleteRetentionPolicy();
serviceProperties.DeleteRetentionPolicy.Enabled = true;
serviceProperties.DeleteRetentionPolicy.RetentionDays = 10;
}
//Set Service Properties with XSCL API
ServiceCORSRule.SetSerivceProperties(service, serviceProperties);
//Get Service Properties with PowerShell
PSSeriviceProperties properties = GetServicePropertiesFromPSH(service);
//Validate Cors, metric, logging
CORSRuleUtil.ValidateCORSRules(corsRules, properties.Cors);
if (service != Constants.ServiceType.File) // File service don't support logging
{
ExpectEqual(serviceProperties.Logging.Version, properties.Logging.Version, "Logging version");
ExpectEqual(serviceProperties.Logging.LoggingOperations.ToString(), properties.Logging.LoggingOperations.ToString(), "Logging Operations");
ExpectEqual(serviceProperties.Logging.RetentionDays.Value, properties.Logging.RetentionDays.Value, "Logging RetentionDays");
}
ExpectEqual(serviceProperties.HourMetrics.Version, properties.HourMetrics.Version, "HourMetrics Version");
ExpectEqual(serviceProperties.HourMetrics.MetricsLevel.ToString(), properties.HourMetrics.MetricsLevel.ToString(), "HourMetrics MetricsLevel");
ExpectEqual(serviceProperties.HourMetrics.RetentionDays.Value, properties.HourMetrics.RetentionDays.Value, "HourMetrics RetentionDays");
ExpectEqual(serviceProperties.MinuteMetrics.Version, properties.MinuteMetrics.Version, "MinuteMetrics Version");
ExpectEqual(serviceProperties.MinuteMetrics.MetricsLevel.ToString(), properties.MinuteMetrics.MetricsLevel.ToString(), "MinuteMetrics MetricsLevel");
ExpectEqual(serviceProperties.MinuteMetrics.RetentionDays.Value, properties.MinuteMetrics.RetentionDays.Value, "MinuteMetrics RetentionDays");
if (service == Constants.ServiceType.Blob)
{
ExpectEqual(serviceProperties.DefaultServiceVersion, properties.DefaultServiceVersion, "DefaultServiceVersion");
ExpectEqual(serviceProperties.DeleteRetentionPolicy.Enabled.ToString(), properties.DeleteRetentionPolicy.Enabled.ToString(), "DeleteRetentionPolicy Enabled");
ExpectEqual(serviceProperties.DeleteRetentionPolicy.RetentionDays.Value, properties.DeleteRetentionPolicy.RetentionDays.Value, "DeleteRetentionPolicy RetentionDays");
serviceProperties.DeleteRetentionPolicy = null;
serviceProperties.DefaultServiceVersion = null;
}
}
}
public void SetCORSRuleNegativeTest()
{
// No allowed origins
PSCorsRule[] corsRules = new PSCorsRule[1];
corsRules[0] = new PSCorsRule()
{
AllowedOrigins = new string[0],
AllowedMethods = CORSRuleUtil.GetRandomMethods(),
AllowedHeaders = CORSRuleUtil.GetRandomHeaders(),
ExposedHeaders = CORSRuleUtil.GetRandomHeaders(),
MaxAgeInSeconds = random.Next(1, 1000)
};
Constants.ServiceType serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set cors rule without allowed origin to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(NoOriginNoMethod0MaxCacheAgeError);
}
else
{
ExpectedContainErrorMessage("Error");
}
// No allowed methods
corsRules[0].AllowedOrigins = CORSRuleUtil.GetRandomOrigins();
corsRules[0].AllowedMethods = new string[0];
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set cors rule without allowed method to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(NoOriginNoMethod0MaxCacheAgeError);
}
else
{
ExpectedContainErrorMessage(string.Format(InvalidMethodsError, string.Empty));
}
// Max age in second is negative.
corsRules[0].AllowedMethods = CORSRuleUtil.GetRandomMethods();
corsRules[0].MaxAgeInSeconds = -1;
serviceType = GetRandomServiceType();
if (lang == Language.PowerShell)
{
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set cors rule to {0} service should fail when max age is negative.", serviceType);
ExpectedContainErrorMessage(NoOriginNoMethod0MaxCacheAgeError);
}
else
{
Test.Assert(CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set cors rule to {0} service should succeed when max age is negative.", serviceType);
}
// Length of one of allowed origins is greater than 256
corsRules[0].MaxAgeInSeconds = random.Next(1, 1000);
corsRules[0].AllowedOrigins = CORSRuleUtil.GetRandomOrigins();
corsRules[0].AllowedOrigins[0] = Utility.GenNameString("origin", 251);
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Set cors rule to {0} service should fail, when allowed origin length is greater than 256.", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
//Count of allowed origin is more than 64.
corsRules[0].AllowedOrigins = CORSRuleUtil.GetRandomOrigins(random.Next(65, 100));
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Allowed origins count is greater than 64, set cors rule {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
// Invalid method name
string invalidMethodName = Utility.GenNameString("");
corsRules[0].AllowedOrigins = CORSRuleUtil.GetRandomOrigins();
corsRules[0].AllowedMethods = CORSRuleUtil.GetRandomMethods();
corsRules[0].AllowedMethods[0] = invalidMethodName;
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Inalid method name, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(string.Format("'{0}' is an invalid HTTP method", invalidMethodName));
}
else
{
ExpectedContainErrorMessage(string.Format(InvalidMethodsError, invalidMethodName.ToUpper()));
}
// More than 2 prefixed allowed headers
corsRules[0].AllowedMethods = CORSRuleUtil.GetRandomMethods();
corsRules[0].AllowedHeaders = CORSRuleUtil.GetRandomHeaders(null, random.Next(3, 10));
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "More than 2 prefixed allowed headers, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
// More than 64 defined allowed headers
corsRules[0].AllowedHeaders = CORSRuleUtil.GetRandomHeaders(random.Next(65, 100));
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "More than 64 defined allowed headers, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
// Allowed header length greater than 256
corsRules[0].AllowedHeaders = CORSRuleUtil.GetRandomHeaders();
corsRules[0].AllowedHeaders[0] = Utility.GenNameString("header", 251);
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Allowed header length greater than 256, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
// More than 2 prefixed exposed headers
corsRules[0].AllowedMethods = CORSRuleUtil.GetRandomMethods();
corsRules[0].ExposedHeaders = CORSRuleUtil.GetRandomHeaders(null, random.Next(3, 10));
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "More than 2 prefixed exposed headers, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
// More than 64 defined exposed headers
corsRules[0].ExposedHeaders = CORSRuleUtil.GetRandomHeaders(random.Next(65, 100));
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "More than 64 defined exposed headers, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
// Exposed header length greater than 256
corsRules[0].ExposedHeaders = CORSRuleUtil.GetRandomHeaders();
corsRules[0].ExposedHeaders[0] = Utility.GenNameString("header", 251);
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Exposed header length greater than 256, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage(InvalidXMLNodeErrors);
}
// big total size
corsRules[0].AllowedOrigins = CORSRuleUtil.GetRandomOrigins(null, true);
corsRules[0].AllowedHeaders = CORSRuleUtil.GetRandomHeaders(null, null, true);
corsRules[0].ExposedHeaders = CORSRuleUtil.GetRandomHeaders(null, null, true);
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "Exposed header length greater than 256, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
var errors = InvalidXMLNodeErrors.ToList();
errors.Add("The command line is too long");
ExpectedContainErrorMessage(errors.ToArray());
}
// 6 CORS ruls
corsRules = CORSRuleUtil.GetRandomValidCORSRules(6);
serviceType = GetRandomServiceType();
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(serviceType, corsRules), "6 CORS rules, set cors rule to {0} service should fail", serviceType);
if (lang == Language.PowerShell)
{
ExpectedContainErrorMessage(CORSRuleInvalidError);
}
else
{
ExpectedContainErrorMessage("You can only specify up to 5 CORS rules per storage service");
}
// Invalid Service Type
corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5));
if (lang == Language.PowerShell)
{
Test.Assert(!CommandAgent.SetAzureStorageCORSRules(Constants.ServiceType.InvalidService, corsRules), "Set cors rules to invalid service type should fail.");
ExpectedContainErrorMessage(string.Format("Unable to match the identifier name {0} to a valid enumerator name. Specify one of the following enumerator names and try again:",
Constants.ServiceType.InvalidService.ToString()));
}
}
