public static void AreEqualDeploymentSettings(ServiceSettings settings, string configPath, string deploymentName, string label, string packagePath, string subscriptionId, DeploymentSettings actual)
{
AreEqualServiceSettings(settings, actual.ServiceSettings);
Assert.AreEqual<string>(configPath, actual.ConfigPath);
Assert.AreEqual<string>(deploymentName, actual.DeploymentName);
Assert.AreEqual<string>(label, actual.Label);
Assert.AreEqual<string>(packagePath, actual.PackagePath);
Assert.AreEqual<string>(subscriptionId, actual.SubscriptionId);
Assert.IsTrue(File.Exists(actual.ConfigPath));
Assert.IsTrue(File.Exists(actual.PackagePath));
}
public void AzureSetDeploymentSlotProcessTestsInvalidFail()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Create new empty settings file
//
ServicePathInfo paths = new ServicePathInfo(files.RootPath);
ServiceSettings settings = new ServiceSettings();
settings.Save(paths.Settings);
Testing.AssertThrows<ArgumentException>(() => new SetAzureDeploymentSlotCommand().SetAzureDeploymentSlotProcess("MyHome", paths.Settings), string.Format(Resources.InvalidServiceSettingElement, "Slot"));
}
}
public void AzureSetDeploymentLocationProcessTestsEmptyFail()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Create new empty settings file
//
ServicePathInfo paths = new ServicePathInfo(files.RootPath);
ServiceSettings settings = new ServiceSettings();
settings.Save(paths.Settings);
Testing.AssertThrows<ArgumentException>(() => new SetAzureDeploymentLocationCommand().SetAzureDeploymentLocationProcess(string.Empty, paths.Settings), string.Format(Resources.InvalidOrEmptyArgumentMessage, "Location"));
}
}
public void AzureSetDeploymentStorageAccountNameProcessTests()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Create new empty settings file
//
ServicePathInfo paths = new ServicePathInfo(files.RootPath);
ServiceSettings settings = new ServiceSettings();
settings.Save(paths.Settings);
new SetAzureDeploymentStorageCommand().SetAzureDeploymentStorageProcess("companystore", paths.Settings);
// Assert storageAccountName is changed
//
settings = ServiceSettings.Load(paths.Settings);
Assert.AreEqual<string>("companystore", settings.StorageAccountName);
}
}
public void AzureSetDeploymentSlotProcessTests()
{
foreach (KeyValuePair<Slot, string> item in AzureDeploymentCmdlets.Model.ArgumentConstants.Slots)
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Create new empty settings file
//
ServicePathInfo paths = new ServicePathInfo(files.RootPath);
ServiceSettings settings = new ServiceSettings();
settings.Save(paths.Settings);
new SetAzureDeploymentSlotCommand().SetAzureDeploymentSlotProcess(item.Value, paths.Settings);
// Assert slot is changed
//
settings = ServiceSettings.Load(paths.Settings);
Assert.AreEqual<string>(item.Value, settings.Slot);
}
}
}
public void AzureSetDeploymentSubscriptionProcessTests()
{
foreach (string item in Data.ValidSubscriptionName)
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Create new empty settings file
//
ServicePathInfo paths = new ServicePathInfo(files.RootPath);
ServiceSettings settings = new ServiceSettings();
settings.Save(paths.Settings);
new SetAzureDeploymentSubscriptionCommand().SetAzureDeploymentSubscriptionProcess(item, paths.Settings);
// Assert subscription is changed
//
settings = ServiceSettings.Load(paths.Settings);
Assert.AreEqual<string>(item, settings.Subscription);
}
}
}
private void InitializeData()
{
ServiceSettings settings;
Data = new Dictionary<ServiceSettingsState, ServiceSettings>();
Data.Add(ServiceSettingsState.Default, new ServiceSettings());
settings = new ServiceSettings();
settings.Location = ArgumentConstants.Locations[Location.SouthCentralUS];
settings.Slot = ArgumentConstants.Slots[Slot.Production];
settings.StorageAccountName = "mystore";
settings.Subscription = "TestSubscription2";
Data.Add(ServiceSettingsState.Sample1, settings);
settings = new ServiceSettings();
settings.Location = ArgumentConstants.Locations[Location.SouthCentralUS];
settings.Slot = ArgumentConstants.Slots[Slot.Production];
settings.StorageAccountName = "mystore";
settings.Subscription = "Does not exist subscription";
Data.Add(ServiceSettingsState.DoesNotExistSubscription, settings);
}
public DeploymentSettings(ServiceSettings settings, string packagePath, string configPath, string label, string deploymentName)
{
Validate.ValidateNullArgument(settings, Resources.InvalidServiceSettingMessage);
Validate.ValidateFileFull(packagePath, Resources.Package);
Validate.ValidateFileFull(configPath, Resources.ServiceConfiguration);
Validate.ValidateStringIsNullOrEmpty(label, "Label");
Validate.ValidateStringIsNullOrEmpty(deploymentName, "Deployment name");
this.ServiceSettings = settings;
this.PackagePath = packagePath;
this.ConfigPath = configPath;
this.Label = label;
this.DeploymentName = deploymentName;
if (!string.IsNullOrEmpty(settings.Subscription))
{
GlobalComponents globalComponents = new GlobalComponents(GlobalPathInfo.GlobalSettingsDirectory);
SubscriptionId = globalComponents.GetSubscriptionId(settings.Subscription);
}
else
{
throw new ArgumentNullException("settings.Subscription", Resources.InvalidSubscriptionNameMessage);
}
}
public static ServiceSettings LoadDefault(string path, string slot, string location, string subscription, string storageAccountName, string suppliedServiceName, string serviceDefinitionName, out string serviceName)
{
ServiceSettings local;
ServiceSettings global = new GlobalComponents(GlobalPathInfo.GlobalSettingsDirectory).GlobalSettings;
ServiceSettings defaultServiceSettings = new ServiceSettings();
// Load local settings if user provided local settings path
//
if (string.IsNullOrEmpty(path))
{
local = new ServiceSettings();
}
else
{
Validate.ValidateFileFull(path, Resources.ServiceSettings);
local = Load(path);
}
defaultServiceSettings._slot = GetDefaultSlot(local.Slot, global.Slot, slot);
defaultServiceSettings._location = GetDefaultLocation(local.Location, global.Location, location);
defaultServiceSettings._subscription = GetDefaultSubscription(local.Subscription, global.Subscription, subscription);
serviceName = GetServiceName(suppliedServiceName, serviceDefinitionName);
defaultServiceSettings._storageAccountName = GetDefaultStorageName(local.StorageAccountName, global.StorageAccountName, storageAccountName, serviceName).ToLower();
return defaultServiceSettings;
}
private void New(string publishSettingsPath, GlobalPathInfo paths)
{
Validate.ValidateNullArgument(paths, string.Empty);
Validate.ValidateStringIsNullOrEmpty(paths.AzureSdkDirectory, Resources.AzureSdkDirectoryName);
Validate.ValidateFileFull(publishSettingsPath, string.Format(Resources.InvalidPath, Resources.PublishSettingsFileName, publishSettingsPath));
Validate.ValidateFileExtention(publishSettingsPath, Resources.PublishSettingsFileExtention);
PublishSettings = General.DeserializeXmlFile<PublishData>(publishSettingsPath, string.Format(Resources.InvalidPublishSettingsSchema, publishSettingsPath));
Certificate = new X509Certificate2(Convert.FromBase64String(PublishSettings.Items[0].ManagementCertificate), string.Empty);
PublishSettings.Items[0].ManagementCertificate = Certificate.Thumbprint;
GlobalSettings = new ServiceSettings();
General.AddCertificateToStore(Certificate);
}
public void ServiceSettingsTest()
{
ServiceSettings settings = new ServiceSettings();
AzureAssert.AreEqualServiceSettings(string.Empty, string.Empty, string.Empty, string.Empty, settings);
}
public static void AreEqualGlobalComponents(string thumbprint, GlobalPathInfo paths, ServiceSettings globalSettings, PublishData publishSettings, GlobalComponents actual)
{
AreEqualGlobalPathInfo(paths, actual.GlobalPaths);
AreEqualServiceSettings(globalSettings, actual.GlobalSettings);
AreEqualPublishSettings(thumbprint, publishSettings, actual);
}
public static void AzureServiceExists(string serviceRootPath, string scaffoldFilePath, string serviceName, ServiceSettings settings = null, WebRoleInfo[] webRoles = null, WorkerRoleInfo[] workerRoles = null, string webScaff = null, string workerScaff = null, RoleInfo[] roles = null)
{
ServiceComponents components = new AzureDeploymentCmdlets.Model.ServiceComponents(new AzureDeploymentCmdlets.Model.ServicePathInfo(serviceRootPath));
ScaffoldingExists(serviceRootPath, scaffoldFilePath);
if (webRoles != null)
{
for (int i = 0; i < webRoles.Length; i++)
{
ScaffoldingExists(Path.Combine(serviceRootPath, webRoles[i].Name), webScaff);
}
}
if (workerRoles != null)
{
for (int i = 0; i < workerRoles.Length; i++)
{
ScaffoldingExists(Path.Combine(serviceRootPath, workerRoles[i].Name), workerScaff);
}
}
AreEqualServiceConfiguration(components.LocalConfig, serviceName, roles);
AreEqualServiceConfiguration(components.CloudConfig, serviceName, roles);
IsValidServiceDefinition(components.Definition, serviceName, webRoles, workerRoles);
AreEqualServiceSettings(settings ?? new ServiceSettings(), components.Settings);
}
public static void AreEqualServiceSettings(string location, string slot, string storageAccountName, string subscriptionName, ServiceSettings actual)
{
Assert.AreEqual<string>(location, actual.Location);
Assert.AreEqual<string>(slot, actual.Slot);
Assert.AreEqual<string>(storageAccountName, actual.StorageAccountName);
Assert.AreEqual<string>(subscriptionName, actual.Subscription);
}
public static void AreEqualServiceSettings(ServiceSettings expected, ServiceSettings actual)
{
AreEqualServiceSettings(expected.Location, expected.Slot, expected.StorageAccountName, expected.Subscription, actual);
}
public void TestInitialize()
{
serviceName = Path.GetRandomFileName();
GlobalPathInfo.GlobalSettingsDirectory = Data.AzureSdkAppDir;
service = new AzureServiceWrapper(Directory.GetCurrentDirectory(), Path.GetRandomFileName(), null);
service.CreateVirtualCloudPackage();
packagePath = service.Paths.CloudPackage;
configPath = service.Paths.CloudConfiguration;
settings = ServiceSettingsTestData.Instance.Data[ServiceSettingsState.Default];
new ImportAzurePublishSettingsCommand().ImportAzurePublishSettingsProcess(Resources.PublishSettingsFileName, Data.AzureSdkAppDir);
}
private void LoadComponents(ServicePathInfo paths)
{
Validate.ValidateNullArgument(paths, string.Format(Resources.NullObjectMessage, "paths"));
Validate.ValidateFileFull(paths.CloudConfiguration, Resources.ServiceConfiguration);
Validate.ValidateFileFull(paths.LocalConfiguration, Resources.ServiceConfiguration);
Validate.ValidateFileFull(paths.Definition, Resources.ServiceDefinition);
Validate.ValidateFileFull(paths.Settings, Resources.ServiceSettings);
Definition = General.DeserializeXmlFile<ServiceDefinition>(paths.Definition);
CloudConfig = General.DeserializeXmlFile<ServiceConfiguration>(paths.CloudConfiguration);
LocalConfig = General.DeserializeXmlFile<ServiceConfiguration>(paths.LocalConfiguration);
Settings = ServiceSettings.Load(paths.Settings);
}