/// <summary>
/// Initializes a new instance of the <see cref="ServerDataServiceCertAuth"/> class
/// </summary>
/// <param name="subscription">The subscription used to connect and authenticate.</param>
/// <param name="serverName">The name of the server to connect to.</param>
private ServerDataServiceCertAuth(
AzureSubscription subscription,
string serverName)
{
this.serverName = serverName;
this.subscription = subscription;
}
public void CanGetAccessTokenCertificateCredentialFromCurrentSubscription()
{
var getClustersCommand = new GetAzureHDInsightClusterCommand();
var waSubscription = new AzureSubscription()
{
Id = IntegrationTestBase.TestCredentials.SubscriptionId,
};
ProfileClient profileClient = new ProfileClient();
profileClient.Profile.Accounts["test"] = new AzureAccount
{
Id = "test",
Type = AzureAccount.AccountType.User,
Properties =
new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, IntegrationTestBase.TestCredentials.SubscriptionId.ToString() }
}
};
profileClient.Profile.Save();
waSubscription.Account = "test";
var accessTokenCreds = getClustersCommand.GetSubscriptionCredentials(waSubscription, AzureSession.CurrentContext.Environment, profileClient.Profile);
Assert.IsInstanceOfType(accessTokenCreds, typeof(HDInsightAccessTokenCredential));
var asAccessTokenCreds = accessTokenCreds as HDInsightAccessTokenCredential;
Assert.AreEqual("abc", asAccessTokenCreds.AccessToken);
Assert.AreEqual(waSubscription.Id, asAccessTokenCreds.SubscriptionId);
}
/// <summary>
/// Creates new WebsitesClient
/// </summary>
/// <param name="subscription">Subscription containing websites to manipulate</param>
/// <param name="logger">The logger action</param>
public WebsitesClient(AzureSubscription subscription, Action<string> logger)
{
Logger = logger;
cloudServiceClient = new CloudServiceClient(subscription, debugStream: logger);
WebsiteManagementClient = AzureSession.ClientFactory.CreateClient<WebSiteManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement);
this.subscription = subscription;
}
/// <summary>
/// Creates new instance from the store client.
/// </summary>
/// <param name="subscription">The Microsoft Azure subscription</param>
public StoreClient(AzureSubscription subscription)
: this(subscription,
AzureSession.ClientFactory.CreateClient<ComputeManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement),
AzureSession.ClientFactory.CreateClient<StoreManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement),
new MarketplaceClient(),
AzureSession.ClientFactory.CreateClient<ManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement))
{
}
/// <summary>
/// Validates that the given subscription is valid.
/// </summary>
/// <param name="subscription">The <see cref="AzureSubscription"/> to validate.</param>
public static void ValidateSubscription(AzureSubscription subscription)
{
if (subscription == null)
{
throw new ArgumentException(
Common.Properties.Resources.InvalidCurrentSubscription);
}
}
public AutomationClient(
AzureSubscription subscription,
AutomationManagement.IAutomationManagementClient automationManagementClient)
{
Requires.Argument("automationManagementClient", automationManagementClient).NotNull();
this.Subscription = subscription;
this.automationManagementClient = automationManagementClient;
}
public EndpointsCommunicator(AzureSubscription subscription)
{
if (subscription != Subscription)
{
Subscription = subscription;
SqlClient = null;
StorageClient = null;
ResourcesClient = null;
}
}
public static void SetCurrentContext(AzureSubscription subscription, AzureEnvironment environment, AzureAccount account)
{
if (environment == null)
{
if (subscription != null && CurrentContext != null &&
subscription.Environment == CurrentContext.Environment.Name)
{
environment = CurrentContext.Environment;
}
else
{
environment = AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud];
}
if (subscription != null)
{
subscription.Environment = environment.Name;
}
}
if (account == null)
{
if (subscription != null && CurrentContext != null && subscription.Account != null)
{
if (CurrentContext.Account != null && subscription.Account == CurrentContext.Account.Id)
{
account = CurrentContext.Account;
}
else
{
throw new ArgumentException(Resources.AccountIdDoesntMatchSubscription, "account");
}
subscription.Account = account.Id;
}
}
if (subscription != null && subscription.Environment != environment.Name)
{
throw new ArgumentException(Resources.EnvironmentNameDoesntMatchSubscription, "environment");
}
CurrentContext = new AzureContext
{
Subscription = subscription,
Account = account,
Environment = environment
};
}
/// <summary>
/// Creates new instance from CloudServiceClient.
/// </summary>
/// <param name="subscription">The subscription data</param>
/// <param name="currentLocation">Directory to do operations in</param>
/// <param name="debugStream">Action used to log http requests/responses</param>
/// <param name="verboseStream">Action used to log detailed client progress</param>
/// <param name="warningStream">Action used to log warning messages</param>
public CloudServiceClient(
AzureSubscription subscription,
string currentLocation = null,
Action<string> debugStream = null,
Action<string> verboseStream = null,
Action<string> warningStream = null)
: this(currentLocation, debugStream, warningStream, verboseStream)
{
Subscription = subscription;
CloudBlobUtility = new CloudBlobUtility();
ManagementClient = AzureSession.ClientFactory.CreateClient<ManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement);
StorageClient = AzureSession.ClientFactory.CreateClient<StorageManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement);
ComputeClient = AzureSession.ClientFactory.CreateClient<ComputeManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement);
}
internal Subscription(AzureSubscription azureSubscription)
{
if (azureSubscription == null)
{
throw new ArgumentNullException();
}
ProfileClient client = new ProfileClient();
var environment = client.GetEnvironmentOrDefault(azureSubscription.Environment);
this.SubscriptionName = azureSubscription.Name;
this.SubscriptionId = azureSubscription.Id.ToString();
this.ServiceEndpoint = new Uri(String.Format("{0}/{1}/services/systemcenter/vmm", environment.GetEndpoint(AzureEnvironment.Endpoint.ServiceManagement).TrimEnd(new[] { '/' }), SubscriptionId));
this.Certificate = FileUtilities.DataStore.GetCertificate(azureSubscription.Account);
this.CredentialType = CredentialType.UseCertificate;
}
public void CanGetBasicAuthCredentialFromCredentials()
{
var getClustersCommand = new GetAzureHDInsightJobCommand();
getClustersCommand.Credential = GetPSCredential(TestCredentials.AzureUserName, TestCredentials.AzurePassword);
var waSubscription = new AzureSubscription()
{
Id = IntegrationTestBase.TestCredentials.SubscriptionId,
};
waSubscription.Account = "test";
var profile = new AzureProfile();
var accessTokenCreds = getClustersCommand.GetJobSubmissionClientCredentials(
waSubscription,
AzureSession.CurrentContext.Environment,
IntegrationTestBase.TestCredentials.WellKnownCluster.DnsName, profile);
Assert.IsInstanceOfType(accessTokenCreds, typeof(BasicAuthCredential));
var asBasicAuthCredentials = accessTokenCreds as BasicAuthCredential;
Assert.IsNotNull(asBasicAuthCredentials);
Assert.AreEqual(IntegrationTestBase.TestCredentials.AzureUserName, asBasicAuthCredentials.UserName);
Assert.AreEqual(IntegrationTestBase.TestCredentials.AzurePassword, asBasicAuthCredentials.Password);
}
/// <summary>
/// Creates new Scheduler Management Convenience Client
/// </summary>
/// <param name="subscription">Subscription containing websites to manipulate</param>
public SchedulerMgmntClient(AzureSubscription subscription)
{
currentSubscription = subscription;
csmClient = AzureSession.ClientFactory.CreateClient<CloudServiceManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement);
schedulerManagementClient = AzureSession.ClientFactory.CreateClient<SchedulerManagementClient>(subscription, AzureEnvironment.Endpoint.ServiceManagement);
//Get RP properties
IDictionary<string, string> dict = schedulerManagementClient.GetResourceProviderProperties().Properties;
//Get available regions
string val = string.Empty;
if (dict.TryGetValue(SupportedRegionsKey, out val))
{
AvailableRegions = new List<string>();
val.Split(',').ToList().ForEach(s => AvailableRegions.Add(s));
}
//Store global counts for max jobs and min recurrence for each plan
if (dict.TryGetValue(FreeMaxJobCountKey, out val))
FreeMaxJobCountValue = Convert.ToInt32(dict[FreeMaxJobCountKey]);
if (dict.TryGetValue(FreeMinRecurrenceKey, out val))
FreeMinRecurrenceValue = TimeSpan.Parse(dict[FreeMinRecurrenceKey]);
if (dict.TryGetValue(StandardMaxJobCountKey, out val))
StandardMaxJobCountValue = Convert.ToInt32(dict[StandardMaxJobCountKey]);
if (dict.TryGetValue(StandardMinRecurrenceKey, out val))
StandardMinRecurrenceValue = TimeSpan.Parse(dict[StandardMinRecurrenceKey]);
if (dict.TryGetValue(PremiumMaxJobCountKey, out val))
PremiumMaxJobCountValue = Convert.ToInt32(dict[PremiumMaxJobCountKey]);
if (dict.TryGetValue(PremiumMinRecurrenceKey, out val))
PremiumMinRecurrenceValue = TimeSpan.Parse(dict[PremiumMinRecurrenceKey]);
}
private void SetMockData()
{
rdfeSubscription1 = new Subscriptions.Models.SubscriptionListOperationResponse.Subscription
{
SubscriptionId = "16E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
SubscriptionName = "RdfeSub1",
SubscriptionStatus = Subscriptions.Models.SubscriptionStatus.Active,
ActiveDirectoryTenantId = "Common"
};
rdfeSubscription2 = new Subscriptions.Models.SubscriptionListOperationResponse.Subscription
{
SubscriptionId = "26E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
SubscriptionName = "RdfeSub2",
SubscriptionStatus = Subscriptions.Models.SubscriptionStatus.Active,
ActiveDirectoryTenantId = "Common"
};
csmSubscription1 = new Azure.Subscriptions.Models.Subscription
{
Id = "Subscriptions/36E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
DisplayName = "CsmSub1",
State = "Active",
SubscriptionId = "36E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"
};
csmSubscription1withDuplicateId = new Azure.Subscriptions.Models.Subscription
{
Id = "Subscriptions/16E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
DisplayName = "RdfeSub1",
State = "Active",
SubscriptionId = "16E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"
};
csmSubscription2 = new Azure.Subscriptions.Models.Subscription
{
Id = "Subscriptions/46E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
DisplayName = "CsmSub2",
State = "Active",
SubscriptionId = "46E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"
};
azureSubscription1 = new AzureSubscription
{
Id = new Guid("56E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub1",
Environment = "Test",
Account = "test",
Properties = new Dictionary<AzureSubscription.Property, string>
{
{ AzureSubscription.Property.Default, "True" }
}
};
azureSubscription2 = new AzureSubscription
{
Id = new Guid("66E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub2",
Environment = "Test",
Account = "test"
};
azureSubscription3withoutUser = new AzureSubscription
{
Id = new Guid("76E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub3",
Environment = "Test",
};
azureEnvironment = new AzureEnvironment
{
Name = "Test",
Endpoints = new Dictionary<AzureEnvironment.Endpoint, string>
{
{ AzureEnvironment.Endpoint.ServiceManagement, "https://umapi.rdfetest.dnsdemo4.com:8443/" },
{ AzureEnvironment.Endpoint.ManagementPortalUrl, "https://windows.azure-test.net" },
{ AzureEnvironment.Endpoint.AdTenant, "https://login.windows-ppe.net/" },
{ AzureEnvironment.Endpoint.ActiveDirectory, "https://login.windows-ppe.net/" },
{ AzureEnvironment.Endpoint.Gallery, "https://current.gallery.azure-test.net" },
{ AzureEnvironment.Endpoint.ResourceManager, "https://api-current.resources.windows-int.net/" },
}
};
azureAccount = new AzureAccount
{
Id = "test",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, azureSubscription1.Id + "," + azureSubscription2.Id }
}
};
newProfileDataPath = System.IO.Path.Combine(AzurePowerShell.ProfileDirectory, AzurePowerShell.ProfileFile);
oldProfileDataPath = System.IO.Path.Combine(AzurePowerShell.ProfileDirectory, AzurePowerShell.OldProfileFile);
oldProfileData = @"<?xml version=""1.0"" encoding=""utf-8""?>
<ProfileData xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/Microsoft.WindowsAzure.Commands.Utilities.Common"">
<DefaultEnvironmentName>AzureCloud</DefaultEnvironmentName>
<Environments>
<AzureEnvironmentData>
<ActiveDirectoryServiceEndpointResourceId>https://management.core.windows.net/</ActiveDirectoryServiceEndpointResourceId>
<AdTenantUrl>https://login.windows-ppe.net/</AdTenantUrl>
<CommonTenantId>Common</CommonTenantId>
<GalleryEndpoint>https://current.gallery.azure-test.net</GalleryEndpoint>
<ManagementPortalUrl>http://go.microsoft.com/fwlink/?LinkId=254433</ManagementPortalUrl>
<Name>Current</Name>
<PublishSettingsFileUrl>d:\Code\azure.publishsettings</PublishSettingsFileUrl>
<ResourceManagerEndpoint>https://api-current.resources.windows-int.net/</ResourceManagerEndpoint>
<ServiceEndpoint>https://umapi.rdfetest.dnsdemo4.com:8443/</ServiceEndpoint>
<SqlDatabaseDnsSuffix>.database.windows.net</SqlDatabaseDnsSuffix>
<StorageEndpointSuffix i:nil=""true"" />
<TrafficManagerDnsSuffix>trafficmanager.net</TrafficManagerDnsSuffix>
</AzureEnvironmentData>
<AzureEnvironmentData>
<ActiveDirectoryServiceEndpointResourceId>https://management.core.windows.net/</ActiveDirectoryServiceEndpointResourceId>
<AdTenantUrl>https://login.windows-ppe.net/</AdTenantUrl>
<CommonTenantId>Common</CommonTenantId>
<GalleryEndpoint>https://df.gallery.azure-test.net</GalleryEndpoint>
<ManagementPortalUrl>https://windows.azure-test.net</ManagementPortalUrl>
<Name>Dogfood</Name>
<PublishSettingsFileUrl>https://auxnext.windows.azure-test.net/publishsettings/index</PublishSettingsFileUrl>
<ResourceManagerEndpoint>https://api-dogfood.resources.windows-int.net</ResourceManagerEndpoint>
<ServiceEndpoint>https://management-preview.core.windows-int.net/</ServiceEndpoint>
<SqlDatabaseDnsSuffix>.database.windows.net</SqlDatabaseDnsSuffix>
<StorageEndpointSuffix i:nil=""true"" />
<TrafficManagerDnsSuffix>trafficmanager.net</TrafficManagerDnsSuffix>
</AzureEnvironmentData>
</Environments>
<Subscriptions>
<AzureSubscriptionData>
<ActiveDirectoryEndpoint i:nil=""true"" />
<ActiveDirectoryServiceEndpointResourceId i:nil=""true"" />
<ActiveDirectoryTenantId i:nil=""true"" />
<ActiveDirectoryUserId i:nil=""true"" />
<CloudStorageAccount i:nil=""true"" />
<GalleryEndpoint i:nil=""true"" />
<IsDefault>true</IsDefault>
<LoginType i:nil=""true"" />
<ManagementCertificate i:nil=""true""/>
<ManagementEndpoint>https://management.core.windows.net/</ManagementEndpoint>
<Name>Test</Name>
<RegisteredResourceProviders xmlns:d4p1=""http://schemas.microsoft.com/2003/10/Serialization/Arrays"" />
<ResourceManagerEndpoint i:nil=""true"" />
<SqlDatabaseDnsSuffix>.database.windows.net</SqlDatabaseDnsSuffix>
<SubscriptionId>06E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E</SubscriptionId>
<TrafficManagerDnsSuffix>trafficmanager.net</TrafficManagerDnsSuffix>
</AzureSubscriptionData>
<AzureSubscriptionData>
<ActiveDirectoryEndpoint i:nil=""true"" />
<ActiveDirectoryServiceEndpointResourceId i:nil=""true"" />
<ActiveDirectoryTenantId>123</ActiveDirectoryTenantId>
<ActiveDirectoryUserId>[email protected]</ActiveDirectoryUserId>
<CloudStorageAccount i:nil=""true"" />
<GalleryEndpoint i:nil=""true"" />
<IsDefault>true</IsDefault>
<LoginType i:nil=""true"" />
<ManagementCertificate i:nil=""true""/>
<ManagementEndpoint>https://management-preview.core.windows-int.net/</ManagementEndpoint>
<Name>Test 2</Name>
<RegisteredResourceProviders xmlns:d4p1=""http://schemas.microsoft.com/2003/10/Serialization/Arrays"" />
<ResourceManagerEndpoint i:nil=""true"" />
<SqlDatabaseDnsSuffix>.database.windows.net</SqlDatabaseDnsSuffix>
<SubscriptionId>06E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1F</SubscriptionId>
<TrafficManagerDnsSuffix>trafficmanager.net</TrafficManagerDnsSuffix>
</AzureSubscriptionData>
<AzureSubscriptionData>
<ActiveDirectoryEndpoint>https://login.windows.net/</ActiveDirectoryEndpoint>
<ActiveDirectoryServiceEndpointResourceId>https://management.core.windows.net/</ActiveDirectoryServiceEndpointResourceId>
<ActiveDirectoryTenantId>72f988bf-86f1-41af-91ab-2d7cd011db47</ActiveDirectoryTenantId>
<ActiveDirectoryUserId>[email protected]</ActiveDirectoryUserId>
<CloudStorageAccount i:nil=""true"" />
<GalleryEndpoint i:nil=""true"" />
<IsDefault>false</IsDefault>
<LoginType i:nil=""true"" />
<ManagementCertificate>3AF24D48B97730E5C4C9CCB12397B5E046F79E09</ManagementCertificate>
<ManagementEndpoint>https://management.core.windows.net/</ManagementEndpoint>
<Name>Test 3</Name>
<RegisteredResourceProviders xmlns:d4p1=""http://schemas.microsoft.com/2003/10/Serialization/Arrays"" />
<ResourceManagerEndpoint i:nil=""true"" />
<SqlDatabaseDnsSuffix>.database.windows.net</SqlDatabaseDnsSuffix>
<SubscriptionId>d1e52cbc-b073-42e2-a0a0-c2f547118a6f</SubscriptionId>
<TrafficManagerDnsSuffix>trafficmanager.net</TrafficManagerDnsSuffix>
</AzureSubscriptionData>
<AzureSubscriptionData>
<ActiveDirectoryEndpoint i:nil=""true"" />
<ActiveDirectoryServiceEndpointResourceId i:nil=""true"" />
<ActiveDirectoryTenantId i:nil=""true"" />
<ActiveDirectoryUserId i:nil=""true"" />
<CloudStorageAccount i:nil=""true"" />
<GalleryEndpoint i:nil=""true"" />
<IsDefault>false</IsDefault>
<LoginType i:nil=""true"" />
<ManagementCertificate>3AF24D48B97730E5C4C9CCB12397B5E046F79E09</ManagementCertificate>
<ManagementEndpoint>https://management.core.chinacloudapi.cn/</ManagementEndpoint>
<Name>Mooncake Test</Name>
<RegisteredResourceProviders xmlns:d4p1=""http://schemas.microsoft.com/2003/10/Serialization/Arrays"" />
<ResourceManagerEndpoint i:nil=""true"" />
<SqlDatabaseDnsSuffix>.database.windows.net</SqlDatabaseDnsSuffix>
<SubscriptionId>c14d7dc5-ed4d-4346-a02f-9f1bcf78fb66</SubscriptionId>
<TrafficManagerDnsSuffix>trafficmanager.net</TrafficManagerDnsSuffix>
</AzureSubscriptionData>
</Subscriptions>
</ProfileData>";
}
private IEnumerable<AzureSubscription> ListServiceManagementSubscriptions(ref AzureAccount account, AzureEnvironment environment, SecureString password, ShowDialog promptBehavior)
{
List<AzureSubscription> result = new List<AzureSubscription>();
if (!environment.IsEndpointSet(AzureEnvironment.Endpoint.ServiceManagement))
{
return result;
}
foreach (var tenant in account.GetPropertyAsArray(AzureAccount.Property.Tenants))
{
try
{
var tenantToken = AzureSession.AuthenticationFactory.Authenticate(ref account, environment, tenant, password, ShowDialog.Never);
using (var subscriptionClient = AzureSession.ClientFactory.CreateCustomClient<WindowsAzure.Subscriptions.SubscriptionClient>(
new TokenCloudCredentials(tenantToken.AccessToken),
environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ServiceManagement)))
{
var subscriptionListResult = subscriptionClient.Subscriptions.List();
foreach (var subscription in subscriptionListResult.Subscriptions)
{
AzureSubscription psSubscription = new AzureSubscription
{
Id = new Guid(subscription.SubscriptionId),
Name = subscription.SubscriptionName,
Environment = environment.Name
};
psSubscription.Properties[AzureSubscription.Property.SupportedModes] = AzureModule.AzureServiceManagement.ToString();
psSubscription.SetProperty(AzureSubscription.Property.Tenants, subscription.ActiveDirectoryTenantId);
AzureSession.SubscriptionTokenCache[Tuple.Create(psSubscription.Id, account.Id)] = tenantToken;
result.Add(psSubscription);
}
}
}
catch (CloudException cEx)
{
WriteOrThrowAadExceptionMessage(cEx);
}
catch (AadAuthenticationException aadEx)
{
WriteOrThrowAadExceptionMessage(aadEx);
}
}
return result;
}
private AzureSubscription MergeSubscriptionProperties(AzureSubscription subscription1, AzureSubscription subscription2)
{
if (subscription1 == null || subscription2 == null)
{
throw new ArgumentNullException("subscription1");
}
if (subscription1.Id != subscription2.Id)
{
throw new ArgumentException("Subscription Ids do not match.");
}
AzureSubscription mergedSubscription = new AzureSubscription
{
Id = subscription1.Id,
Name = subscription1.Name,
Environment = subscription1.Environment,
Account = subscription1.Account ?? subscription2.Account
};
// Merge all properties
foreach (AzureSubscription.Property property in Enum.GetValues(typeof(AzureSubscription.Property)))
{
string propertyValue = subscription1.GetProperty(property) ?? subscription2.GetProperty(property);
if (propertyValue != null)
{
mergedSubscription.Properties[property] = propertyValue;
}
}
// Merge RegisteredResourceProviders
var registeredProviders = subscription1.GetPropertyAsArray(AzureSubscription.Property.RegisteredResourceProviders)
.Union(subscription2.GetPropertyAsArray(AzureSubscription.Property.RegisteredResourceProviders), StringComparer.CurrentCultureIgnoreCase);
mergedSubscription.SetProperty(AzureSubscription.Property.RegisteredResourceProviders, registeredProviders.ToArray());
// Merge SupportedMode
var supportedModes = subscription1.GetPropertyAsArray(AzureSubscription.Property.SupportedModes)
.Union(subscription2.GetPropertyAsArray(AzureSubscription.Property.SupportedModes), StringComparer.CurrentCultureIgnoreCase);
mergedSubscription.SetProperty(AzureSubscription.Property.SupportedModes, supportedModes.ToArray());
// Merge Tenants
var tenants = subscription1.GetPropertyAsArray(AzureSubscription.Property.Tenants)
.Union(subscription2.GetPropertyAsArray(AzureSubscription.Property.Tenants), StringComparer.CurrentCultureIgnoreCase);
mergedSubscription.SetProperty(AzureSubscription.Property.Tenants, tenants.ToArray());
return mergedSubscription;
}
public AzureSubscription SetSubscriptionAsCurrent(string name, string accountName)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name", string.Format(Resources.InvalidSubscription, name));
}
AzureSubscription currentSubscription = null;
var subscription = Profile.Subscriptions.Values.FirstOrDefault(s => s.Name == name);
if (subscription == null)
{
throw new ArgumentException(string.Format(Resources.InvalidSubscription, name), "name");
}
else
{
currentSubscription = new AzureSubscription { Id = subscription.Id };
currentSubscription = MergeSubscriptionProperties(subscription, currentSubscription);
var environment = GetEnvironmentOrDefault(subscription.Environment);
accountName = string.IsNullOrEmpty(accountName) ? subscription.Account : accountName;
var account = GetAccount(accountName);
currentSubscription.Account = account.Id;
AzureSession.SetCurrentContext(currentSubscription, environment, account);
}
return currentSubscription;
}
public AzureSubscription AddOrSetSubscription(AzureSubscription subscription)
{
if (subscription == null)
{
throw new ArgumentNullException("Subscription needs to be specified.", "subscription");
}
if (subscription.Environment == null)
{
throw new ArgumentNullException("Environment needs to be specified.", "subscription.Environment");
}
// Validate environment
GetEnvironmentOrDefault(subscription.Environment);
if (Profile.Subscriptions.ContainsKey(subscription.Id))
{
Profile.Subscriptions[subscription.Id] = MergeSubscriptionProperties(subscription, Profile.Subscriptions[subscription.Id]);
}
else
{
Debug.Assert(!string.IsNullOrEmpty(subscription.Account));
if (!Profile.Accounts.ContainsKey(subscription.Account))
{
throw new KeyNotFoundException(string.Format("The specified account {0} does not exist in profile accounts", subscription.Account));
}
Profile.Subscriptions[subscription.Id] = subscription;
}
// Update in-memory subscription
if (AzureSession.CurrentContext != null && AzureSession.CurrentContext.Subscription != null &&
AzureSession.CurrentContext.Subscription.Id == subscription.Id)
{
var account = GetAccountOrDefault(subscription.Account);
var environment = GetEnvironmentOrDefault(subscription.Environment);
AzureSession.SetCurrentContext(Profile.Subscriptions[subscription.Id], environment, account);
}
return Profile.Subscriptions[subscription.Id];
}
private void SetMockData()
{
azureSubscription1 = new AzureSubscription
{
Id = new Guid("56E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub1",
Environment = "Test",
Account = "test",
Properties = new Dictionary<AzureSubscription.Property, string>
{
{ AzureSubscription.Property.Default, "True" }
}
};
azureSubscription2 = new AzureSubscription
{
Id = new Guid("66E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub2",
Environment = "Test",
Account = "test"
};
azureEnvironment = new AzureEnvironment
{
Name = "Test",
Endpoints = new Dictionary<AzureEnvironment.Endpoint, string>
{
{ AzureEnvironment.Endpoint.ServiceManagement, "https://umapi.rdfetest.dnsdemo4.com:8443/" },
{ AzureEnvironment.Endpoint.ManagementPortalUrl, "https://windows.azure-test.net" },
{ AzureEnvironment.Endpoint.AdTenant, "https://login.windows-ppe.net/" },
{ AzureEnvironment.Endpoint.ActiveDirectory, "https://login.windows-ppe.net/" },
{ AzureEnvironment.Endpoint.Gallery, "https://current.gallery.azure-test.net" },
{ AzureEnvironment.Endpoint.ResourceManager, "https://api-current.resources.windows-int.net/" },
}
};
azureAccount = new AzureAccount
{
Id = "test",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, azureSubscription1.Id + "," + azureSubscription2.Id }
}
};
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment rdfeEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
TestEnvironment csmEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
TestEnvironment currentEnvironment = (mode == AzureModule.AzureResourceManager ? csmEnvironment : rdfeEnvironment);
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
SetEndpointsToDefaults(rdfeEnvironment, csmEnvironment);
SetAuthenticationFactory(mode, rdfeEnvironment, csmEnvironment);
AzureEnvironment environment = new AzureEnvironment { Name = testEnvironmentName };
Debug.Assert(currentEnvironment != null);
environment.Endpoints[AzureEnvironment.Endpoint.ActiveDirectory] = currentEnvironment.ActiveDirectoryEndpoint.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Gallery] = currentEnvironment.GalleryUri.AbsoluteUri;
if (csmEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ResourceManager] = csmEnvironment.BaseUri.AbsoluteUri;
}
if (rdfeEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ServiceManagement] = rdfeEnvironment.BaseUri.AbsoluteUri;
}
if (!client.Profile.Environments.ContainsKey(testEnvironmentName))
{
client.AddOrSetEnvironment(environment);
}
testSubscription = new AzureSubscription()
{
Id = new Guid(currentEnvironment.SubscriptionId),
Name = testSubscriptionName,
Environment = testEnvironmentName,
Account = currentEnvironment.UserName,
Properties = new Dictionary<AzureSubscription.Property,string>
{
{ AzureSubscription.Property.Default, "True"},
{ AzureSubscription.Property.StorageAccount, Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")},
}
};
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, currentEnvironment.SubscriptionId},
}
};
client.Profile.Subscriptions[testSubscription.Id] = testSubscription;
client.Profile.Accounts[testAccount.Id] = testAccount;
client.SetSubscriptionAsCurrent(testSubscription.Name, testSubscription.Account);
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment rdfeEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
TestEnvironment csmEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
TestEnvironment currentEnvironment = (mode == AzureModule.AzureResourceManager ? csmEnvironment : rdfeEnvironment);
string jwtToken;
if (mode == AzureModule.AzureResourceManager)
{
jwtToken = csmEnvironment.Credentials != null ?
((TokenCloudCredentials)csmEnvironment.Credentials).Token : null;
}
else if (mode == AzureModule.AzureServiceManagement)
{
jwtToken = rdfeEnvironment.Credentials != null ?
((TokenCloudCredentials)rdfeEnvironment.Credentials).Token : null;
}
else
{
throw new ArgumentException("Invalid module mode.");
}
SetEndpointsToDefaults(rdfeEnvironment, csmEnvironment);
/*
WindowsAzureProfile.Instance.TokenProvider = new FakeAccessTokenProvider(
jwtToken,
csmEnvironment.UserName,
csmEnvironment.AuthorizationContext == null ? null : csmEnvironment.AuthorizationContext.TenatId);
*/
if (HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback)
{
AzureSession.AuthenticationFactory = new MockAuthenticationFactory();
}
else
{
AzureSession.AuthenticationFactory = new MockAuthenticationFactory(currentEnvironment.UserName, jwtToken);
}
AzureEnvironment environment = new AzureEnvironment { Name = testEnvironmentName };
Debug.Assert(currentEnvironment != null);
environment.Endpoints[AzureEnvironment.Endpoint.ActiveDirectory] = currentEnvironment.ActiveDirectoryEndpoint.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Gallery] = currentEnvironment.GalleryUri.AbsoluteUri;
if (csmEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ResourceManager] = csmEnvironment.BaseUri.AbsoluteUri;
}
if (rdfeEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ServiceManagement] = rdfeEnvironment.BaseUri.AbsoluteUri;
}
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
if (!client.Profile.Environments.ContainsKey(testEnvironmentName))
{
client.AddOrSetEnvironment(environment);
}
testSubscription = new AzureSubscription()
{
Id = new Guid(currentEnvironment.SubscriptionId),
Name = testSubscriptionName,
Environment = testEnvironmentName,
Account = currentEnvironment.UserName,
Properties = new Dictionary<AzureSubscription.Property,string>
{
{ AzureSubscription.Property.Default, "True"},
{ AzureSubscription.Property.StorageAccount, Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")},
}
};
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, currentEnvironment.SubscriptionId},
}
};
client.Profile.Subscriptions[testSubscription.Id] = testSubscription;
client.Profile.Accounts[testAccount.Id] = testAccount;
client.SetSubscriptionAsCurrent(testSubscription.Name, testSubscription.Account);
}
private void SetMockData()
{
rdfeSubscription1 = new Subscriptions.Models.SubscriptionListOperationResponse.Subscription
{
SubscriptionId = "16E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
SubscriptionName = "RdfeSub1",
SubscriptionStatus = Subscriptions.Models.SubscriptionStatus.Active,
ActiveDirectoryTenantId = "Common"
};
rdfeSubscription2 = new Subscriptions.Models.SubscriptionListOperationResponse.Subscription
{
SubscriptionId = "26E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
SubscriptionName = "RdfeSub2",
SubscriptionStatus = Subscriptions.Models.SubscriptionStatus.Active,
ActiveDirectoryTenantId = "Common"
};
csmSubscription1 = new Azure.Subscriptions.Models.Subscription
{
Id = "Subscriptions/36E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
DisplayName = "CsmSub1",
State = "Active",
SubscriptionId = "36E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"
};
csmSubscription1withDuplicateId = new Azure.Subscriptions.Models.Subscription
{
Id = "Subscriptions/16E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
DisplayName = "RdfeSub1",
State = "Active",
SubscriptionId = "16E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"
};
csmSubscription2 = new Azure.Subscriptions.Models.Subscription
{
Id = "Subscriptions/46E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E",
DisplayName = "CsmSub2",
State = "Active",
SubscriptionId = "46E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"
};
azureSubscription1 = new AzureSubscription
{
Id = new Guid("56E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub1",
Environment = "Test",
Account = "test",
Properties = new Dictionary<AzureSubscription.Property, string>
{
{ AzureSubscription.Property.Default, "True" }
}
};
azureSubscription2 = new AzureSubscription
{
Id = new Guid("66E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub2",
Environment = "Test",
Account = "test"
};
azureSubscription3withoutUser = new AzureSubscription
{
Id = new Guid("76E3F6FD-A3AA-439A-8FC4-1F5C41D2AD1E"),
Name = "LocalSub3",
Environment = "Test",
};
azureEnvironment = new AzureEnvironment
{
Name = "Test",
Endpoints = new Dictionary<AzureEnvironment.Endpoint, string>
{
{ AzureEnvironment.Endpoint.ServiceManagement, "https://umapi.rdfetest.dnsdemo4.com:8443/" },
{ AzureEnvironment.Endpoint.ManagementPortalUrl, "https://windows.azure-test.net" },
{ AzureEnvironment.Endpoint.AdTenant, "https://login.windows-ppe.net/" },
{ AzureEnvironment.Endpoint.ActiveDirectory, "https://login.windows-ppe.net/" },
{ AzureEnvironment.Endpoint.Gallery, "https://current.gallery.azure-test.net" },
{ AzureEnvironment.Endpoint.ResourceManager, "https://api-current.resources.windows-int.net/" },
}
};
azureAccount = new AzureAccount
{
Id = "test",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, azureSubscription1.Id + "," + azureSubscription2.Id }
}
};
}
/// <summary>
/// Executes the set subscription cmdlet operation.
/// </summary>
public override void ExecuteCmdlet()
{
AzureSubscription subscription = null;
if (!string.IsNullOrEmpty(SubscriptionId) && string.IsNullOrEmpty(SubscriptionName))
{
subscription = ProfileClient.GetSubscription(new Guid(SubscriptionId));
Environment = subscription.Environment;
}
else if (string.IsNullOrEmpty(SubscriptionId) && !string.IsNullOrEmpty(SubscriptionName))
{
subscription = ProfileClient.GetSubscription(SubscriptionName);
Environment = subscription.Environment;
}
else
{
subscription = new AzureSubscription();
subscription.Id = new Guid(SubscriptionId);
subscription.Name = SubscriptionName;
}
AzureEnvironment environment = ProfileClient.GetEnvironment(Environment, ServiceEndpoint, ResourceManagerEndpoint);
if (environment == null)
{
environment = DefaultProfileClient.GetEnvironment(Environment, ServiceEndpoint, ResourceManagerEndpoint);
}
if (environment == null)
{
throw new ArgumentException("ServiceEndpoint and ResourceManagerEndpoint values do not "+
"match existing environment. Please use Environment parameter.");
}
else
{
subscription.Environment = environment.Name;
}
if (ServiceEndpoint != null || ResourceManagerEndpoint != null)
{
WriteWarning("Please use Environment parameter to specify subscription environment. This "+
"warning will be converted into an error in the upcoming release.");
}
if (Certificate != null)
{
ProfileClient.ImportCertificate(Certificate);
subscription.Account = Certificate.Thumbprint;
AzureAccount account = new AzureAccount
{
Id = Certificate.Thumbprint,
Type = AzureAccount.AccountType.Certificate
};
account.SetOrAppendProperty(AzureAccount.Property.Subscriptions, subscription.Id.ToString());
ProfileClient.AddOrSetAccount(account);
if (subscription.Account == null)
{
subscription.Account = account.Id;
}
}
if (subscription.Account == null)
{
throw new ArgumentException("Certificate is required for creating a new subscription.");
}
if (!string.IsNullOrEmpty(CurrentStorageAccountName))
{
subscription.Properties[AzureSubscription.Property.StorageAccount] = CurrentStorageAccountName;
}
subscription = ProfileClient.AddOrSetSubscription(subscription);
if (PassThru)
{
WriteObject(subscription);
}
}
/// <summary>
/// Connect to Azure SQL Server using certificate authentication.
/// </summary>
/// <param name="serverName">The name of the server to connect to</param>
/// <param name="subscription">The subscription data to use for authentication</param>
/// <returns>A new <see cref="ServerDataServiceCertAuth"/> context,
/// or <c>null</c> if an error occurred.</returns>
internal ServerDataServiceCertAuth GetServerDataServiceByCertAuth(
string serverName,
AzureSubscription subscription)
{
ServerDataServiceCertAuth context = null;
SqlDatabaseCmdletBase.ValidateSubscription(subscription);
try
{
context = ServerDataServiceCertAuth.Create(serverName, subscription);
}
catch (ArgumentException e)
{
SqlDatabaseExceptionHandler.WriteErrorDetails(this, string.Empty, e);
context = null;
}
return context;
}
public void AddOrSetAzureSubscriptionUpdatesInMemory()
{
MockDataStore dataStore = new MockDataStore();
ProfileClient.DataStore = dataStore;
ProfileClient client = new ProfileClient();
client.AddOrSetAccount(azureAccount);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
AzureSession.SetCurrentContext(azureSubscription1, azureEnvironment, azureAccount);
azureSubscription1.Properties[AzureSubscription.Property.StorageAccount] = "testAccount";
Assert.Equal(azureSubscription1.Id, AzureSession.CurrentContext.Subscription.Id);
Assert.Equal(azureSubscription1.Properties[AzureSubscription.Property.StorageAccount],
AzureSession.CurrentContext.Subscription.Properties[AzureSubscription.Property.StorageAccount]);
var newSubscription = new AzureSubscription
{
Id = azureSubscription1.Id,
Environment = azureSubscription1.Environment,
Account = azureSubscription1.Account,
Name = azureSubscription1.Name
};
newSubscription.Properties[AzureSubscription.Property.StorageAccount] = "testAccount1";
client.AddOrSetSubscription(newSubscription);
var newSubscriptionFromProfile = client.Profile.Subscriptions[newSubscription.Id];
Assert.Equal(newSubscription.Id, AzureSession.CurrentContext.Subscription.Id);
Assert.Equal(newSubscription.Id, newSubscriptionFromProfile.Id);
Assert.Equal(newSubscription.Properties[AzureSubscription.Property.StorageAccount],
AzureSession.CurrentContext.Subscription.Properties[AzureSubscription.Property.StorageAccount]);
Assert.Equal(newSubscription.Properties[AzureSubscription.Property.StorageAccount],
newSubscriptionFromProfile.Properties[AzureSubscription.Property.StorageAccount]);
}
private IEnumerable<AzureSubscription> ListServiceManagementSubscriptions(AzureAccount account, AzureEnvironment environment, SecureString password, ShowDialog promptBehavior, string[] tenants)
{
List<AzureSubscription> result = new List<AzureSubscription>();
if (!environment.IsEndpointSet(AzureEnvironment.Endpoint.ServiceManagement))
{
return result;
}
foreach (var tenant in tenants)
{
try
{
var tenantAccount = new AzureAccount();
CopyAccount(account, tenantAccount);
var tenantToken = AzureSession.AuthenticationFactory.Authenticate(tenantAccount, environment, tenant, password, ShowDialog.Never);
if (tenantAccount.Id == account.Id)
{
tenantAccount = account;
}
tenantAccount.SetOrAppendProperty(AzureAccount.Property.Tenants, new string[] { tenant });
using (var subscriptionClient = AzureSession.ClientFactory.CreateCustomClient<WindowsAzure.Subscriptions.SubscriptionClient>(
new TokenCloudCredentials(tenantToken.AccessToken),
environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ServiceManagement)))
{
var subscriptionListResult = subscriptionClient.Subscriptions.List();
foreach (var subscription in subscriptionListResult.Subscriptions)
{
// only add the subscription if it's actually in this tenant
if (subscription.ActiveDirectoryTenantId == tenant)
{
AzureSubscription psSubscription = new AzureSubscription
{
Id = new Guid(subscription.SubscriptionId),
Name = subscription.SubscriptionName,
Environment = environment.Name
};
psSubscription.Properties[AzureSubscription.Property.SupportedModes] =
AzureModule.AzureServiceManagement.ToString();
psSubscription.SetProperty(AzureSubscription.Property.Tenants,
subscription.ActiveDirectoryTenantId);
psSubscription.Account = tenantAccount.Id;
tenantAccount.SetOrAppendProperty(AzureAccount.Property.Subscriptions,
new string[] { psSubscription.Id.ToString() });
result.Add(psSubscription);
}
}
}
AddOrSetAccount(tenantAccount);
}
catch (CloudException cEx)
{
WriteOrThrowAadExceptionMessage(cEx);
}
catch (AadAuthenticationException aadEx)
{
WriteOrThrowAadExceptionMessage(aadEx);
}
}
return result;
}
public void ImportPublishSettingsAddsSecondCertificate()
{
MockDataStore dataStore = new MockDataStore();
ProfileClient.DataStore = dataStore;
ProfileClient client = new ProfileClient();
var newSubscription = new AzureSubscription
{
Id = new Guid("f62b1e05-af8f-4203-8f97-421089adc053"),
Name = "Microsoft Azure Sandbox 9-220",
Environment = EnvironmentName.AzureCloud,
Account = azureAccount.Id
};
azureAccount.SetProperty(AzureAccount.Property.Subscriptions, newSubscription.Id.ToString());
client.AddOrSetAccount(azureAccount);
client.AddOrSetSubscription(newSubscription);
client.Profile.Save();
client = new ProfileClient();
dataStore.WriteFile("ImportPublishSettingsLoadsAndReturnsSubscriptions.publishsettings",
Properties.Resources.ValidProfile);
client.AddOrSetEnvironment(azureEnvironment);
var subscriptions = client.ImportPublishSettings("ImportPublishSettingsLoadsAndReturnsSubscriptions.publishsettings", azureEnvironment.Name);
Assert.Equal(2, client.Profile.Accounts.Count());
var certAccount = client.Profile.Accounts.Values.First(a => a.Type == AzureAccount.AccountType.Certificate);
var userAccount = client.Profile.Accounts.Values.First(a => a.Type == AzureAccount.AccountType.User);
Assert.True(subscriptions.All(s => s.Account == certAccount.Id));
Assert.Equal(azureAccount.Id, client.Profile.Subscriptions.Values.First(s => s.Id == newSubscription.Id).Account);
Assert.True(userAccount.GetPropertyAsArray(AzureAccount.Property.Subscriptions).Contains(newSubscription.Id.ToString()));
Assert.True(certAccount.GetPropertyAsArray(AzureAccount.Property.Subscriptions).Contains(newSubscription.Id.ToString()));
Assert.Equal(6, subscriptions.Count);
Assert.Equal(6, client.Profile.Subscriptions.Count);
}
public CloudServiceClientTests()
{
AzurePowerShell.ProfileDirectory = Test.Utilities.Common.Data.AzureSdkAppDir;
storageService = new MockStorageService()
.Add(a => SetupStorage(serviceName.ToLowerInvariant(), a))
.Add(a => SetupStorage(storageName.ToLowerInvariant(), a));
services = new MockServicesHost()
.Add(s =>
{
s.Name = serviceName;
s.AddDeployment(d =>
{
d.Slot = DeploymentSlot.Production;
d.Name = "mydeployment";
});
});
subscription = new AzureSubscription
{
Properties = new Dictionary<AzureSubscription.Property,string> {{AzureSubscription.Property.Default, "True"}},
Id = Guid.NewGuid(),
Name = Test.Utilities.Common.Data.Subscription1,
};
cloudBlobUtilityMock = new Mock<CloudBlobUtility>();
cloudBlobUtilityMock.Setup(f => f.UploadPackageToBlob(
It.IsAny<StorageManagementClient>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<BlobRequestOptions>())).Returns(new Uri("http://www.packageurl.azure.com"));
clientMocks = new ClientMocks(subscription.Id);
services.InitializeMocks(clientMocks.ComputeManagementClientMock);
storageService.InitializeMocks(clientMocks.StorageManagementClientMock);
client = new CloudServiceClient(subscription,
clientMocks.ManagementClientMock.Object,
clientMocks.StorageManagementClientMock.Object,
clientMocks.ComputeManagementClientMock.Object
)
{
CloudBlobUtility = cloudBlobUtilityMock.Object
};
}
public PSCacheClient(AzureSubscription currentSubscription)
{
client = AzureSession.ClientFactory.CreateClient<ManagedCacheClient>(currentSubscription, AzureEnvironment.Endpoint.ServiceManagement);
}
/// <summary>
/// Creates new TagsClient
/// </summary>
/// <param name="subscription">Subscription containing resources to manipulate</param>
public TagsClient(AzureSubscription subscription)
: this(AzureSession.ClientFactory.CreateClient<ResourceManagementClient>(subscription, AzureEnvironment.Endpoint.ResourceManager))
{
}
/// <summary>
/// Common helper method for other tests to create a unit test subscription
/// that connects to the mock server.
/// </summary>
/// <param name="powershell">The powershell instance used for the test.</param>
public static AzureSubscription SetupUnitTestSubscription(System.Management.Automation.PowerShell powershell)
{
UnitTestHelper.ImportAzureModule(powershell);
// Set the client certificate used in the subscription
powershell.Runspace.SessionStateProxy.SetVariable(
"clientCertificate",
UnitTestHelper.GetUnitTestClientCertificate());
ProfileClient client = new ProfileClient();
client.Profile.Environments[UnitTestEnvironmentName] = new AzureEnvironment
{
Name = UnitTestEnvironmentName,
Endpoints = new Dictionary<AzureEnvironment.Endpoint, string>
{
{AzureEnvironment.Endpoint.ServiceManagement, MockHttpServer.DefaultHttpsServerPrefixUri.AbsoluteUri},
{AzureEnvironment.Endpoint.SqlDatabaseDnsSuffix, ".database.windows.net"}
}
};
var account = new AzureAccount
{
Id = UnitTestHelper.GetUnitTestClientCertificate().Thumbprint,
Type = AzureAccount.AccountType.Certificate
};
var subscription = new AzureSubscription
{
Id = new Guid(UnitTestSubscriptionId),
Name = UnitTestSubscriptionName,
Environment = UnitTestEnvironmentName,
Account = account.Id
};
client.AddOrSetAccount(account);
client.AddOrSetSubscription(subscription);
client.SetSubscriptionAsCurrent(UnitTestSubscriptionName, account.Id);
client.Profile.Save();
return subscription;
}
public void UpdateSubscription(AzureSubscription subscription)
{
throw new NotImplementedException();
}
