internal AzureHDInsightSubscriptionResolverSimulator() { var certificate = new X509Certificate2(Convert.FromBase64String(IntegrationTestBase.TestCredentials.Certificate), string.Empty); ProfileClient.DataStore.AddCertificate(certificate); ProfileClient profileClient = new ProfileClient(); profileClient.Profile.Accounts[certificate.Thumbprint] = new AzureAccount { Id = certificate.Thumbprint, Type = AzureAccount.AccountType.Certificate, Properties = new Dictionary<AzureAccount.Property, string> { { AzureAccount.Property.Subscriptions, IntegrationTestBase.TestCredentials.SubscriptionId.ToString() } } }; profileClient.Profile.Save(); this.knownSubscriptions = new AzureSubscription[] { new AzureSubscription() { Id = IntegrationTestBase.TestCredentials.SubscriptionId, Account = certificate.Thumbprint, Environment = EnvironmentName.AzureCloud }, }; }
private static AzureSubscription PublishSubscriptionToAzureSubscription( ProfileClient azureProfileClient, PublishDataPublishProfile profile, PublishDataPublishProfileSubscription s, string environment) { var certificate = GetCertificate(profile, s); if (string.IsNullOrEmpty(environment)) { var azureEnvironment = azureProfileClient.GetEnvironment(environment, s.ServiceManagementUrl ?? profile.Url, null); if (azureEnvironment != null) { environment = azureEnvironment.Name; } else { environment = EnvironmentName.AzureCloud; } } return new AzureSubscription { Id = new Guid(s.Id), Name = s.Name, Environment = environment, Account = certificate.Thumbprint }; }
public void SetsAzureEnvironment() { Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>(); string name = "Katal"; ProfileClient client = new ProfileClient(); client.AddOrSetEnvironment(new AzureEnvironment { Name = name }); SetAzureEnvironmentCommand cmdlet = new SetAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Name = "KATaL", PublishSettingsFileUrl = "http://microsoft.com", ServiceEndpoint = "endpoint.net", ManagementPortalUrl = "management portal url", StorageEndpoint = "endpoint.net", GalleryEndpoint = "galleryendpoint" }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); commandRuntimeMock.Verify(f => f.WriteObject(It.IsAny<AzureEnvironment>()), Times.Once()); client = new ProfileClient(); AzureEnvironment env = client.Profile.Environments["KaTaL"]; Assert.Equal(env.Name.ToLower(), cmdlet.Name.ToLower()); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], cmdlet.PublishSettingsFileUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ServiceManagement], cmdlet.ServiceEndpoint); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ManagementPortalUrl], cmdlet.ManagementPortalUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.Gallery], "galleryendpoint"); }
internal IJobSubmissionClient GetClient(string cluster) { cluster.ArgumentNotNull("ClusterEndpoint"); IJobSubmissionClient client = null; ProfileClient profileClient = new ProfileClient(); string currentEnvironmentName = this.CurrentSubscription == null ? null : this.CurrentSubscription.Environment; var clientCredential = this.GetJobSubmissionClientCredentials( this.CurrentSubscription, profileClient.GetEnvironmentOrDefault(currentEnvironmentName), cluster, profileClient.Profile); if (clientCredential != null) { client = ServiceLocator.Instance.Locate<IAzureHDInsightJobSubmissionClientFactory>().Create(clientCredential); client.SetCancellationSource(this.tokenSource); if (this.Logger.IsNotNull()) { client.AddLogWriter(this.Logger); } return client; } throw new InvalidOperationException("Expected either a Subscription or Credential parameter."); }
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); }
public void AddsAzureEnvironment() { Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>(); AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Name = "Katal", PublishSettingsFileUrl = "http://microsoft.com", ServiceEndpoint = "endpoint.net", ManagementPortalUrl = "management portal url", StorageEndpoint = "endpoint.net", GalleryEndpoint = "http://galleryendpoint.com" }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); commandRuntimeMock.Verify(f => f.WriteObject(It.IsAny<PSObject>()), Times.Once()); ProfileClient client = new ProfileClient(); AzureEnvironment env = client.GetEnvironmentOrDefault("KaTaL"); Assert.Equal(env.Name, cmdlet.Name); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], cmdlet.PublishSettingsFileUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ServiceManagement], cmdlet.ServiceEndpoint); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ManagementPortalUrl], cmdlet.ManagementPortalUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.Gallery], "http://galleryendpoint.com"); }
public static IEnumerable<AzureSubscription> ImportAzureSubscription(Stream stream, ProfileClient azureProfileClient, string environment) { var publishData = DeserializePublishData(stream); PublishDataPublishProfile profile = publishData.Items.Single(); stream.Close(); return profile.Subscription.Select(s => PublishSubscriptionToAzureSubscription(azureProfileClient, profile, s, environment)); }
public void RemovesAzureEnvironment() { var commandRuntimeMock = new Mock<ICommandRuntime>(); commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny<string>(), It.IsAny<string>())).Returns(true); const string name = "test"; ProfileClient client = new ProfileClient(); client.AddOrSetEnvironment(new AzureEnvironment { Name = name }); client.Profile.Save(); var cmdlet = new RemoveAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Force = true, Name = name }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); client = new ProfileClient(); Assert.False(client.Profile.Environments.ContainsKey(name)); }
protected override void BeginProcessing() { if (!string.IsNullOrEmpty(SubscriptionDataFile)) { ProfileClient = new ProfileClient(SubscriptionDataFile); } else { ProfileClient = new ProfileClient(); } ProfileClient.WarningLog = WriteWarning; ProfileClient.DebugLog = WriteDebug; }
/// <summary> /// When running this test double check that the certificate used in Azure.PublishSettings has not expired. /// </summary> public PublishContextTests() { AzurePowerShell.ProfileDirectory = Test.Utilities.Common.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]; ProfileClient.DataStore = new MockDataStore(); ProfileClient client = new ProfileClient(); ProfileClient.DataStore.WriteFile(Test.Utilities.Common.Data.ValidPublishSettings.First(), File.ReadAllText(Test.Utilities.Common.Data.ValidPublishSettings.First())); client.ImportPublishSettings(Test.Utilities.Common.Data.ValidPublishSettings.First(), null); client.Profile.Save(); }
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 AzurePSCmdlet() { defaultProfileClient = new ProfileClient(); if (AzureSession.CurrentContext.Subscription == null && defaultProfileClient.Profile.DefaultSubscription != null) { try { AzureSession.SetCurrentContext( defaultProfileClient.Profile.DefaultSubscription, defaultProfileClient.GetEnvironmentOrDefault(defaultProfileClient.Profile.DefaultSubscription.Environment), defaultProfileClient.GetAccountOrNull(defaultProfileClient.Profile.DefaultSubscription.Account)); } catch (ArgumentException) { // if context cannot be loaded, start with no account/subscription } } }
internal IHDInsightClient GetClient() { this.CurrentSubscription.ArgumentNotNull("CurrentSubscription"); ProfileClient client = new ProfileClient(); var subscriptionCredentials = this.GetSubscriptionCredentials( this.CurrentSubscription, client.GetEnvironmentOrDefault(this.CurrentSubscription.Environment), client.Profile); var clientInstance = ServiceLocator.Instance.Locate<IAzureHDInsightClusterManagementClientFactory>().Create(subscriptionCredentials); clientInstance.SetCancellationSource(this.tokenSource); if (this.Logger.IsNotNull()) { clientInstance.AddLogWriter(this.Logger); } return clientInstance; }
public PublishContext( ServiceSettings settings, string packagePath, string cloudConfigPath, string serviceName, string deploymentName, string rootPath) { Validate.ValidateNullArgument(settings, Resources.InvalidServiceSettingMessage); Validate.ValidateStringIsNullOrEmpty(packagePath, "packagePath"); Validate.ValidateFileFull(cloudConfigPath, Resources.ServiceConfiguration); Validate.ValidateStringIsNullOrEmpty(serviceName, "serviceName"); this.ServiceSettings = settings; this.PackagePath = packagePath; this.CloudConfigPath = cloudConfigPath; this.RootPath = rootPath; this.ServiceName = serviceName; this.DeploymentName = string.IsNullOrEmpty(deploymentName) ? char.ToLower(ServiceSettings.Slot[0]) + DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss-ffff") : deploymentName; if (!string.IsNullOrEmpty(settings.Subscription)) { try { ProfileClient client = new ProfileClient(); SubscriptionId = client.Profile.Subscriptions.Values.Where(s => s.Name == settings.Subscription) .Select(s => s.Id.ToString()) .First(); } catch (Exception) { throw new ArgumentException(string.Format(Resources.SubscriptionIdNotFoundMessage, settings.Subscription), "settings.Subscription"); } } else { throw new ArgumentNullException("settings.Subscription", Resources.InvalidSubscriptionNameMessage); } }
public static AzureSubscription GetCurrentSubscription() { string certificateThumbprint1 = "jb245f1d1257fw27dfc402e9ecde37e400g0176r"; ProfileClient profileClient = new ProfileClient(); profileClient.Profile.Accounts[certificateThumbprint1] = new AzureAccount() { Id = certificateThumbprint1, Type = AzureAccount.AccountType.Certificate }; profileClient.Profile.Save(); return new AzureSubscription() { Id = IntegrationTestBase.TestCredentials.SubscriptionId, // Use fake certificate thumbprint Account = certificateThumbprint1 }; }
public AzurePSCmdlet() { DefaultProfileClient = new ProfileClient(); if (AzureSession.CurrentContext.Subscription == null && DefaultProfileClient.Profile.DefaultSubscription != null) { try { AzureSession.SetCurrentContext( DefaultProfileClient.Profile.DefaultSubscription, DefaultProfileClient.GetEnvironmentOrDefault( DefaultProfileClient.Profile.DefaultSubscription.Environment), DefaultProfileClient.GetAccountOrNull(DefaultProfileClient.Profile.DefaultSubscription.Account)); } catch { // Ignore anything at this point } } }
/// <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; }
/// <summary> /// Create a temporary Azure SDK directory to simulate global files. /// </summary> /// <param name="publishSettingsPath"> /// Path to the publish settings. /// </param> /// <returns>The path to the temporary Azure SDK directory.</returns> public string CreateAzureSdkDirectoryAndImportPublishSettings(string publishSettingsPath) { Debug.Assert(!string.IsNullOrEmpty(publishSettingsPath)); Debug.Assert(File.Exists(publishSettingsPath)); Debug.Assert(string.IsNullOrEmpty(AzureSdkPath)); AzureSdkPath = CreateDirectory("AzureSdk"); ProfileClient client = new ProfileClient(); ProfileClient.DataStore.WriteFile(publishSettingsPath, File.ReadAllText(publishSettingsPath)); client.ImportPublishSettings(publishSettingsPath, null); client.Profile.Save(); return AzureSdkPath; }
public void AddsEnvironmentWithStorageEndpoint() { Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>(); PSObject actual = null; commandRuntimeMock.Setup(f => f.WriteObject(It.IsAny<object>())) .Callback((object output) => actual = (PSObject)output); AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Name = "Katal", PublishSettingsFileUrl = "http://microsoft.com", StorageEndpoint = "core.windows.net" }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); commandRuntimeMock.Verify(f => f.WriteObject(It.IsAny<PSObject>()), Times.Once()); ProfileClient client = new ProfileClient(); AzureEnvironment env = client.Profile.Environments["KaTaL"]; Assert.Equal(env.Name, cmdlet.Name); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], actual.GetVariableValue<string>(AzureEnvironment.Endpoint.PublishSettingsFileUrl.ToString())); }
public void IgnoresAddingDuplicatedEnvironment() { Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>(); AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Name = "Katal", PublishSettingsFileUrl = "http://microsoft.com", ServiceEndpoint = "endpoint.net", ManagementPortalUrl = "management portal url", StorageEndpoint = "endpoint.net" }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); ProfileClient client = new ProfileClient(); int count = client.Profile.Environments.Count; // Add again cmdlet.Name = "kAtAl"; Testing.AssertThrows<Exception>(() => cmdlet.ExecuteCmdlet()); }
public void CanGetSubscriptionsCertificateCredentialFromCurrentSubscription() { var getClustersCommand = new GetAzureHDInsightClusterCommand(); var waSubscription = GetCurrentSubscription(); ProfileClient profileClient = new ProfileClient(); var subscriptionCreds = getClustersCommand.GetSubscriptionCredentials(waSubscription, AzureSession.CurrentContext.Environment, profileClient.Profile); Assert.IsInstanceOfType(subscriptionCreds, typeof(HDInsightCertificateCredential)); var asCertificateCreds = subscriptionCreds as HDInsightCertificateCredential; Assert.AreEqual(waSubscription.Id, asCertificateCreds.SubscriptionId); Assert.IsNotNull(asCertificateCreds.Certificate); }
public void CanGetJobSubmissionCertificateCredentialFromCurrentSubscription() { var getClustersCommand = new GetAzureHDInsightJobCommand(); var waSubscription = GetCurrentSubscription(); ProfileClient profileClient = new ProfileClient(); var subscriptionCreds = getClustersCommand.GetJobSubmissionClientCredentials( waSubscription, AzureSession.CurrentContext.Environment, IntegrationTestBase.TestCredentials.WellKnownCluster.DnsName, profileClient.Profile); Assert.IsInstanceOfType(subscriptionCreds, typeof(JobSubmissionCertificateCredential)); var asCertificateCreds = subscriptionCreds as JobSubmissionCertificateCredential; Assert.AreEqual(waSubscription.Id, asCertificateCreds.SubscriptionId); Assert.AreEqual(IntegrationTestBase.TestCredentials.WellKnownCluster.DnsName, asCertificateCreds.Cluster); }
public void AddsEnvironmentWithMinimumInformation() { Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>(); AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Name = "Katal", PublishSettingsFileUrl = "http://microsoft.com" }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); commandRuntimeMock.Verify(f => f.WriteObject(It.IsAny<PSObject>()), Times.Once()); ProfileClient client = new ProfileClient(); AzureEnvironment env = client.Profile.Environments["KaTaL"]; Assert.Equal(env.Name, cmdlet.Name); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], cmdlet.PublishSettingsFileUrl); }
/// <summary> /// Setup certificates required for the unit tests /// </summary> public static void SetupCertificates() { TestingTracingInterceptor.AddToContext(); ProfileClient.DataStore = new MockDataStore(); AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(); var newGuid = Guid.NewGuid(); ProfileClient client = new ProfileClient(); client.Profile.Subscriptions[newGuid] = new AzureSubscription { Id = newGuid, Name = "test", Environment = EnvironmentName.AzureCloud, Account = "test" }; client.Profile.Accounts["test"] = new AzureAccount { Id = "test", Type = AzureAccount.AccountType.User, Properties = new Dictionary<AzureAccount.Property, string> { {AzureAccount.Property.Subscriptions, newGuid.ToString()} } }; client.Profile.Accounts[UnitTestHelper.GetUnitTestClientCertificate().Thumbprint] = new AzureAccount { Id = UnitTestHelper.GetUnitTestClientCertificate().Thumbprint, Type = AzureAccount.AccountType.Certificate, Properties = new Dictionary<AzureAccount.Property, string> { {AzureAccount.Property.Subscriptions, newGuid.ToString()} } }; client.Profile.Accounts[UnitTestHelper.GetUnitTestSSLCertificate().Thumbprint] = new AzureAccount { Id = UnitTestHelper.GetUnitTestSSLCertificate().Thumbprint, Type = AzureAccount.AccountType.Certificate, Properties = new Dictionary<AzureAccount.Property, string> { {AzureAccount.Property.Subscriptions, newGuid.ToString()} } }; AzureSession.SetCurrentContext(client.Profile.Subscriptions[newGuid], null, client.Profile.Accounts["test"]); client.Profile.Save(); // Check if the cert has been installed Process proc = ExecuteProcess( "netsh", string.Format( CultureInfo.InvariantCulture, "http show sslcert ipport=0.0.0.0:{0}", DefaultHttpsServerPrefixUri.Port)); if (proc.ExitCode != 0) { // Install the SSL and client certificates to the LocalMachine store X509Store store = new X509Store(StoreName.My, StoreLocation.LocalMachine); store.Open(OpenFlags.ReadWrite); store.Add(UnitTestHelper.GetUnitTestSSLCertificate()); store.Add(UnitTestHelper.GetUnitTestClientCertificate()); store.Close(); store = new X509Store(StoreName.Root, StoreLocation.LocalMachine); store.Open(OpenFlags.ReadWrite); store.Add(UnitTestHelper.GetUnitTestSSLCertificate()); store.Add(UnitTestHelper.GetUnitTestClientCertificate()); store.Close(); // Remove any existing certs on the default port proc = ExecuteProcess( "netsh", string.Format( CultureInfo.InvariantCulture, "http delete sslcert ipport=0.0.0.0:{0}", DefaultHttpsServerPrefixUri.Port)); // Install the ssl cert on the default port proc = ExecuteProcess( "netsh", string.Format( CultureInfo.InvariantCulture, "http add sslcert ipport=0.0.0.0:{0} certhash={1} appid={2:B}", DefaultHttpsServerPrefixUri.Port, UnitTestHelper.GetUnitTestSSLCertificate().Thumbprint, MockHttpServer.HttpsAppId)); if (proc.ExitCode != 0) { throw new InvalidOperationException(string.Format( CultureInfo.InvariantCulture, "Unable to add ssl certificate: {0}", proc.StandardOutput.ReadToEnd())); } } }
protected AzureSubscription GetCurrentSubscription(string Subscription, X509Certificate2 certificate) { if (Subscription.IsNotNullOrEmpty()) { this.WriteWarning("The -Subscription parameter is deprecated, Please use Select-AzureSubscription -Current to select a subscription to use."); ProfileClient client = new ProfileClient(); var subscriptionResolver = ServiceLocator.Instance.Locate<IAzureHDInsightSubscriptionResolverFactory>().Create(client.Profile); var resolvedSubscription = subscriptionResolver.ResolveSubscription(Subscription); if (certificate.IsNotNull() && resolvedSubscription.Account != certificate.Thumbprint) { ProfileClient.DataStore.AddCertificate(certificate); } if (resolvedSubscription.IsNull()) { throw new ArgumentException( string.Format( CultureInfo.InvariantCulture, "Failed to retrieve Certificate for the subscription '{0}'." + "Please use Select-AzureSubscription -Current to select a subscription.", Subscription)); } return resolvedSubscription; } else { #if DEBUG // we need this for the tests to mock out the current subscription. if (this.HasCurrentSubscription) { return this.CurrentContext.Subscription; } return testSubscription; #else return this.CurrentContext.Subscription; #endif } }