internal IHDInsightClient GetClient(bool ignoreSslErrors = false)
{
this.CurrentSubscription.ArgumentNotNull("CurrentSubscription");
ProfileClient client = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
var subscriptionCredentials = this.GetSubscriptionCredentials(
this.CurrentSubscription,
client.GetEnvironmentOrDefault(this.CurrentSubscription.Environment),
client.Profile);
if (this.Endpoint.IsNotNull())
{
subscriptionCredentials.Endpoint = this.Endpoint;
}
var clientInstance = ServiceLocator.Instance.Locate<IAzureHDInsightClusterManagementClientFactory>().Create(subscriptionCredentials, ignoreSslErrors);
clientInstance.SetCancellationSource(this.tokenSource);
if (this.Logger.IsNotNull())
{
clientInstance.AddLogWriter(this.Logger);
}
return clientInstance;
}
internal AzureHDInsightSubscriptionResolverSimulator()
{
var certificate = new X509Certificate2(Convert.FromBase64String(IntegrationTestBase.TestCredentials.Certificate), string.Empty);
AzureSession.DataStore.AddCertificate(certificate);
ProfileClient profileClient = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
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
},
};
}
internal IJobSubmissionClient GetClient(string cluster)
{
cluster.ArgumentNotNull("ClusterEndpoint");
IJobSubmissionClient client = null;
ProfileClient profileClient = new ProfileClient(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
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 static AzureSMProfile CreateAzureSMProfile(string storageAccount)
{
var profile = new AzureSMProfile();
var client = new ProfileClient(profile);
var tenantId = Guid.NewGuid();
var subscriptionId = Guid.NewGuid();
var account = new AzureAccount
{
Id = "*****@*****.**",
Type = AzureAccount.AccountType.User
};
account.SetProperty(AzureAccount.Property.Tenants, tenantId.ToString());
account.SetProperty(AzureAccount.Property.Subscriptions, subscriptionId.ToString());
var subscription = new AzureSubscription()
{
Id = subscriptionId,
Name = "Test Subscription 1",
Environment = EnvironmentName.AzureCloud,
Account = account.Id,
};
subscription.SetProperty(AzureSubscription.Property.Tenants, tenantId.ToString());
subscription.SetProperty(AzureSubscription.Property.StorageAccount, storageAccount);
client.AddOrSetAccount(account);
client.AddOrSetSubscription(subscription);
client.SetSubscriptionAsDefault(subscriptionId, account.Id);
return profile;
}
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));
}
internal IHDInsightClient GetClient()
{
this.CurrentSubscription.ArgumentNotNull("CurrentSubscription");
ProfileClient client = new ProfileClient();
var subscriptionCredentials = this.GetSubscriptionCredentials(
this.CurrentSubscription,
client.GetEnvironmentOrDefault(this.CurrentSubscription.Environment),
client.Profile);
if (this.Endpoint.IsNotNull())
{
subscriptionCredentials.Endpoint = this.Endpoint;
}
var clientInstance = ServiceLocator.Instance.Locate<IAzureHDInsightClusterManagementClientFactory>().Create(subscriptionCredentials);
clientInstance.SetCancellationSource(this.tokenSource);
if (this.Logger.IsNotNull())
{
clientInstance.AddLogWriter(this.Logger);
}
return clientInstance;
}
public EnvironmentSetupHelper()
{
var datastore = new MemoryDataStore();
AzureSession.DataStore = datastore;
var profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
var rmprofile = new AzureRMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
rmprofile.Environments.Add("foo", AzureEnvironment.PublicEnvironments.Values.FirstOrDefault());
rmprofile.Context = new AzureContext(new AzureSubscription(), new AzureAccount(), rmprofile.Environments["foo"], new AzureTenant());
rmprofile.Context.Subscription.Environment = "foo";
if (AzureRmProfileProvider.Instance.Profile == null)
{
AzureRmProfileProvider.Instance.Profile = rmprofile;
}
AzureSession.DataStore = datastore;
ProfileClient = new ProfileClient(profile);
// Ignore SSL errors
System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true;
AdalTokenCache.ClearCookies();
// Set RunningMocked
TestMockSupport.RunningMocked = HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback;
}
// TODO: fix flaky test
//[Trait(Category.AcceptanceType, Category.CheckIn)]
public void SetsAzureEnvironment()
{
Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>();
string name = "Katal";
ProfileClient client = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
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<PSAzureEnvironment>()), Times.Once());
client = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
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");
}
public void SetAzureSubscriptionDerivesEnvironmentFromEnvironmentParameterOnAdd()
{
SetAzureSubscriptionCommand cmdlt = new SetAzureSubscriptionCommand();
// Setup
ProfileClient client = new ProfileClient();
client.AddOrSetEnvironment(azureEnvironment);
client.Profile.Save();
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.SubscriptionId = Guid.NewGuid().ToString();
cmdlt.SubscriptionName = "NewSubscriptionName";
cmdlt.CurrentStorageAccountName = "NewCloudStorage";
cmdlt.Environment = azureEnvironment.Name;
cmdlt.Certificate = SampleCertificate;
// Act
cmdlt.InvokeBeginProcessing();
cmdlt.ExecuteCmdlet();
cmdlt.InvokeEndProcessing();
// Verify
client = new ProfileClient();
var newSubscription = client.Profile.Subscriptions[new Guid(cmdlt.SubscriptionId)];
Assert.Equal(cmdlt.SubscriptionName, newSubscription.Name);
Assert.Equal(cmdlt.Environment, newSubscription.Environment);
Assert.Equal(cmdlt.CurrentStorageAccountName, newSubscription.GetProperty(AzureSubscription.Property.StorageAccount));
}
public void AddsAzureEnvironment()
{
var profile = new AzureProfile();
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",
Profile = profile
};
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
commandRuntimeMock.Verify(f => f.WriteObject(It.IsAny<PSAzureEnvironment>()), Times.Once());
ProfileClient client = new ProfileClient(profile);
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 void ClearAzureProfileClearsDefaultProfile()
{
ClearAzureProfileCommand cmdlt = new ClearAzureProfileCommand();
// Setup
var profile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
AzurePSCmdlet.CurrentProfile = profile;
ProfileClient client = new ProfileClient(profile);
client.AddOrSetAccount(azureAccount);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
client.Profile.Save();
cmdlt.CommandRuntime = commandRuntimeMock;
cmdlt.Force = new SwitchParameter(true);
// Act
cmdlt.InvokeBeginProcessing();
cmdlt.ExecuteCmdlet();
cmdlt.InvokeEndProcessing();
// Verify
client = new ProfileClient(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
Assert.Equal(0, client.Profile.Subscriptions.Count);
Assert.Equal(0, client.Profile.Accounts.Count);
Assert.Equal(2, client.Profile.Environments.Count); //only default environments
}
public static AzureSubscription GetCurrentSubscription()
{
string certificateThumbprint1 = "jb245f1d1257fw27dfc402e9ecde37e400g0176r";
var newSubscription = new AzureSubscription()
{
Id = IntegrationTestBase.TestCredentials.SubscriptionId,
// Use fake certificate thumbprint
Account = certificateThumbprint1,
Environment = "AzureCloud"
};
newSubscription.Properties[AzureSubscription.Property.Default] = "True";
ProfileClient profileClient = new ProfileClient(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
profileClient.Profile.Accounts[certificateThumbprint1] =
new AzureAccount()
{
Id = certificateThumbprint1,
Type = AzureAccount.AccountType.Certificate
};
profileClient.Profile.Subscriptions[newSubscription.Id] = newSubscription;
profileClient.Profile.Save();
return profileClient.Profile.Subscriptions[newSubscription.Id];
}
public static IHDInsightSubscriptionCredentials GetAccessTokenCredentials(this IAzureHDInsightCommonCommandBase command,
AzureSubscription currentSubscription, AzureAccount azureAccount, AzureEnvironment environment)
{
ProfileClient profileClient = new ProfileClient();
AzureContext azureContext = new AzureContext
{
Subscription = currentSubscription,
Environment = environment,
Account = azureAccount
};
var cloudCredentials = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(azureContext) as AccessTokenCredential;
if (cloudCredentials != null)
{
var field= typeof(AccessTokenCredential).GetField("token", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance);
var accessToken = field.GetValue(cloudCredentials) as IAccessToken;
if (accessToken != null)
{
return new HDInsightAccessTokenCredential()
{
SubscriptionId = currentSubscription.Id,
AccessToken = accessToken.AccessToken
};
}
}
return null;
}
public void SetAzureSubscriptionAddsSubscriptionWithCertificate()
{
SetAzureSubscriptionCommand cmdlt = new SetAzureSubscriptionCommand();
// Setup
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.SubscriptionId = Guid.NewGuid().ToString();
cmdlt.SubscriptionName = "NewSubscriptionName";
cmdlt.CurrentStorageAccountName = "NewCloudStorage";
cmdlt.Certificate = SampleCertificate;
// Act
cmdlt.InvokeBeginProcessing();
cmdlt.ExecuteCmdlet();
cmdlt.InvokeEndProcessing();
// Verify
ProfileClient client = new ProfileClient();
var newSubscription = client.Profile.Subscriptions[new Guid(cmdlt.SubscriptionId)];
var newAccount = client.Profile.Accounts[SampleCertificate.Thumbprint];
Assert.Equal(cmdlt.SubscriptionName, newSubscription.Name);
Assert.Equal(EnvironmentName.AzureCloud, newSubscription.Environment);
Assert.Equal(cmdlt.CurrentStorageAccountName, newSubscription.GetProperty(AzureSubscription.Property.StorageAccount));
Assert.Equal(newAccount.Id, newSubscription.Account);
Assert.Equal(AzureAccount.AccountType.Certificate, newAccount.Type);
Assert.Equal(SampleCertificate.Thumbprint, newAccount.Id);
Assert.Equal(cmdlt.SubscriptionId, newAccount.GetProperty(AzureAccount.Property.Subscriptions));
}
public void ProfileMigratesOldData()
{
MockDataStore dataStore = new MockDataStore();
dataStore.VirtualStore[oldProfileDataPath] = oldProfileData;
ProfileClient.DataStore = dataStore;
ProfileClient client = new ProfileClient();
Assert.False(dataStore.FileExists(oldProfileDataPath));
Assert.True(dataStore.FileExists(newProfileDataPath));
}
public void ProfileMigratesOldData()
{
MemoryDataStore dataStore = new MemoryDataStore();
dataStore.VirtualStore[oldProfileDataPath] = oldProfileData;
AzureSession.DataStore = dataStore;
currentProfile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
Assert.False(dataStore.FileExists(oldProfileDataPath));
Assert.True(dataStore.FileExists(newProfileDataPath));
}
public void NewProfileFromCertificateWithNullsThrowsArgumentNullException()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
AzureSMProfile newProfile = new AzureSMProfile();
ProfileClient client1 = new ProfileClient(newProfile);
Assert.Throws<ArgumentNullException>(() =>
client1.InitializeProfile(null, Guid.NewGuid(), new X509Certificate2(), "foo"));
Assert.Throws<ArgumentNullException>(() =>
client1.InitializeProfile(AzureEnvironment.PublicEnvironments["AzureCloud"], Guid.NewGuid(), null, "foo"));
}
public EnvironmentSetupHelper()
{
ProfileClient.DataStore = new MockDataStore();
client = new ProfileClient();
// Ignore SSL errors
System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true;
// Set RunningMocked
if (HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback)
{
TestMockSupport.RunningMocked = true;
}
}
/// <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];
AzureSession.DataStore = new MemoryDataStore();
ProfileClient client = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
AzureSession.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();
}
public void SetupEnvironment()
{
base.SetupEnvironment(AzureModule.AzureResourceManager);
TestEnvironment csmEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
if (csmEnvironment.SubscriptionId != null)
{
//Overwrite the default subscription and default account
//with ones using user ID and tenant ID from auth context
var user = GetUser(csmEnvironment);
var tenantId = GetTenantId(csmEnvironment);
var testSubscription = new AzureSubscription()
{
Id = new Guid(csmEnvironment.SubscriptionId),
Name = ProfileClient.Profile.DefaultSubscription.Name,
Environment = ProfileClient.Profile.DefaultSubscription.Environment,
Account = user,
Properties = new Dictionary <AzureSubscription.Property, string>
{
{ AzureSubscription.Property.Default, "True" },
{
AzureSubscription.Property.StorageAccount,
Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")
},
{ AzureSubscription.Property.Tenants, tenantId },
}
};
var testAccount = new AzureAccount()
{
Id = user,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary <AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, csmEnvironment.SubscriptionId },
}
};
ProfileClient.Profile.Accounts.Remove(ProfileClient.Profile.DefaultSubscription.Account);
ProfileClient.Profile.Subscriptions[testSubscription.Id] = testSubscription;
ProfileClient.Profile.Accounts[testAccount.Id] = testAccount;
ProfileClient.SetSubscriptionAsDefault(testSubscription.Name, testSubscription.Account);
ProfileClient.Profile.Save();
}
}
/// <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);
X509Certificate2 certificate = UnitTestHelper.GetUnitTestClientCertificate();
Guid subscriptionId = new Guid(UnitTestSubscriptionId);
// Set the client certificate used in the subscription
powershell.Runspace.SessionStateProxy.SetVariable(
"clientCertificate",
certificate);
var profile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
AzurePSCmdlet.CurrentProfile = profile;
ProfileClient client = new ProfileClient(profile);
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 = certificate.Thumbprint,
Type = AzureAccount.AccountType.Certificate
};
var subscription = new AzureSubscription
{
Id = subscriptionId,
Name = UnitTestSubscriptionName,
Environment = UnitTestEnvironmentName,
Account = account.Id
};
client.AddOrSetAccount(account);
client.AddOrSetSubscription(subscription);
client.SetSubscriptionAsDefault(UnitTestSubscriptionName, account.Id);
client.Profile.Save();
return(subscription);
}
/// <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];
AzureSession.DataStore = new MemoryDataStore();
ProfileClient client = new ProfileClient(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
AzureSession.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(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
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;
}
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;
}
/// <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);
X509Certificate2 certificate = UnitTestHelper.GetUnitTestClientCertificate();
Guid subscriptionId = new Guid(UnitTestSubscriptionId);
// Set the client certificate used in the subscription
powershell.Runspace.SessionStateProxy.SetVariable(
"clientCertificate",
certificate);
var profile = new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
AzureSMCmdlet.CurrentProfile = profile;
ProfileClient client = new ProfileClient(profile);
client.AddOrSetEnvironment(new AzureEnvironment
{
Name = UnitTestEnvironmentName,
ServiceManagementUrl = MockHttpServer.DefaultHttpsServerPrefixUri.AbsoluteUri,
SqlDatabaseDnsSuffix = ".database.windows.net"
});
var account = new AzureAccount
{
Id = certificate.Thumbprint,
Type = AzureAccount.AccountType.Certificate
};
var subscription = new AzureSubscription
{
Id = subscriptionId.ToString(),
Name = UnitTestSubscriptionName,
};
account.ExtendedProperties.Add("Subscriptions", subscription.Id);
subscription.SetEnvironment(UnitTestEnvironmentName);
subscription.SetAccount(account.Id);
client.AddOrSetAccount(account);
client.AddOrSetSubscription(subscription);
client.SetSubscriptionAsDefault(subscriptionId, account.Id);
client.Profile.Save();
return(subscription);
}
/// <summary>
/// TODO: Migrate all code that references this method to use AzureContext
/// </summary>
/// <typeparam name="TClient"></typeparam>
/// <param name="subscription"></param>
/// <param name="endpoint"></param>
/// <returns></returns>
public virtual TClient CreateClient <TClient>(AzureSubscription subscription, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient>
{
if (subscription == null)
{
throw new ApplicationException(Resources.InvalidCurrentSubscription);
}
ProfileClient profileClient = new ProfileClient();
AzureContext context = new AzureContext
{
Subscription = subscription,
Environment = profileClient.GetEnvironmentOrDefault(subscription.Environment),
Account = profileClient.GetAccount(subscription.Account)
};
return(CreateClient <TClient>(context, endpoint));
}
private void Initialize(IPictureparkClientSettings settings, HttpClient httpClient)
{
Outputs = new OutputClient(settings, httpClient);
Contents = new ContentClient(settings, httpClient);
BusinessProcesses = new BusinessProcessClient(settings, httpClient);
DocumentHistory = new DocumentHistoryClient(settings, httpClient);
JsonSchemas = new JsonSchemaClient(settings, httpClient);
Permissions = new PermissionClient(settings, httpClient);
PublicAccess = new PublicAccessClient(settings, httpClient);
Shares = new ShareClient(settings, httpClient);
Users = new UserClient(settings, httpClient);
Schemas = new SchemaClient((BusinessProcessClient)BusinessProcesses, settings, httpClient);
Transfers = new TransferClient((BusinessProcessClient)BusinessProcesses, settings, httpClient);
ListItems = new ListItemClient((BusinessProcessClient)BusinessProcesses, settings, httpClient);
Profile = new ProfileClient(settings, httpClient);
ServiceProviders = new ServiceProviderClient(settings, httpClient);
}
public override void ExecuteCmdlet()
{
AzureAccount azureAccount = new AzureAccount();
azureAccount.Type = ServicePrincipal.IsPresent
? AzureAccount.AccountType.ServicePrincipal
: AzureAccount.AccountType.User;
SecureString password = null;
if (Credential != null)
{
azureAccount.Id = Credential.UserName;
password = Credential.Password;
}
if (!string.IsNullOrEmpty(Tenant))
{
azureAccount.SetProperty(AzureAccount.Property.Tenants, new[] { Tenant });
}
var account = ProfileClient.AddAccountAndLoadSubscriptions(azureAccount, ProfileClient.GetEnvironmentOrDefault(Environment), password);
if (account != null)
{
WriteVerbose(string.Format(Resources.AddAccountAdded, azureAccount.Id));
if (ProfileClient.Profile.DefaultSubscription != null)
{
WriteVerbose(string.Format(Resources.AddAccountShowDefaultSubscription,
ProfileClient.Profile.DefaultSubscription.Name));
}
WriteVerbose(Resources.AddAccountViewSubscriptions);
WriteVerbose(Resources.AddAccountChangeSubscription);
string subscriptionsList = account.GetProperty(AzureAccount.Property.Subscriptions);
string tenantsList = account.GetProperty(AzureAccount.Property.Tenants);
if (subscriptionsList == null)
{
WriteWarning(string.Format(Resources.NoSubscriptionAddedMessage, azureAccount.Id));
}
WriteObject(account.ToPSAzureAccount());
}
}
public override void ExecuteCmdlet()
{
List <AzureEnvironment> environments = ProfileClient.ListEnvironments(Name);
List <PSObject> output = new List <PSObject>();
foreach (AzureEnvironment e in environments)
{
List <object> args = new List <object> {
"Name", e.Name
};
foreach (AzureEnvironment.Endpoint property in Enum.GetValues(typeof(AzureEnvironment.Endpoint)))
{
args.AddRange(new object[] { property, e.GetEndpoint(property) });
}
output.Add(base.ConstructPSObject(null, args.ToArray()));
}
WriteObject(output, true);
}
public void CanGetJobSubmissionCertificateCredentialFromCurrentSubscription()
{
var getClustersCommand = new GetAzureHDInsightJobCommand();
var waSubscription = GetCurrentSubscription();
ProfileClient profileClient = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
var subscriptionCreds = getClustersCommand.GetJobSubmissionClientCredentials(
waSubscription,
profileClient.Profile.Context.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 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
}
}
}
private void UpdateSubscriptionRegisteredProviders(AzureSMProfile profile, IAzureSubscription subscription, List <string> providers)
{
if (providers != null && providers.Count > 0)
{
subscription.SetOrAppendProperty(AzureSubscription.Property.RegisteredResourceProviders,
providers.ToArray());
try
{
ProfileClient profileClient = new ProfileClient(profile);
profileClient.AddOrSetSubscription(subscription);
profileClient.Profile.Save();
}
catch (KeyNotFoundException)
{
// if using a subscription data file, do not write registration to disk
// long term solution is using -Profile parameter
}
}
}
protected IAzureSubscription 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(new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile)));
var subscriptionResolver =
ServiceLocator.Instance.Locate <IAzureHDInsightSubscriptionResolverFactory>().Create(client.Profile);
var resolvedSubscription = subscriptionResolver.ResolveSubscription(Subscription);
if (certificate.IsNotNull() && resolvedSubscription.GetAccount() != certificate.Thumbprint)
{
AzureSession.Instance.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 (Profile.Context.Subscription != null)
{
return(this.Profile.Context.Subscription);
}
return(testSubscription);
#else
return(this.Profile.Context.Subscription);
#endif
}
}
public void SetAzureSubscriptionThrowsExceptionWithoutCertificateOnAdd()
{
SetAzureSubscriptionCommand cmdlt = new SetAzureSubscriptionCommand();
// Setup
ProfileClient client = new ProfileClient();
client.AddOrSetEnvironment(azureEnvironment);
client.Profile.Save();
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.SubscriptionId = Guid.NewGuid().ToString();
cmdlt.SubscriptionName = "NewSubscriptionName";
cmdlt.CurrentStorageAccountName = "NewCloudStorage";
cmdlt.Environment = azureEnvironment.Name;
// Verify
cmdlt.InvokeBeginProcessing();
Assert.Throws <ArgumentException>(() => cmdlt.ExecuteCmdlet());
}
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(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
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 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(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
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);
}
}
// Gets the customer's Azure account and subscription information
private static AzureProfile GetAzureProfile()
{
AzureProfile profile = new AzureProfile();
ProfileClient profileClient = new ProfileClient(profile);
AzureAccount azureAccount = new AzureAccount()
{
Type = AzureAccount.AccountType.User
};
// Prompts the user for their credentials and retrieves their account/subscription info
profileClient.AddAccountAndLoadSubscriptions(azureAccount, profile.Environments[EnvironmentName.AzureCloud], null);
// By default, the first subscription is chosen
if (profileClient.Profile.Subscriptions.Count > 1)
{
SelectSubscription(profileClient.Profile);
}
return(profileClient.Profile);
}
static void Main(string[] args)
{
NewTask.Combine taskcombine = new NewTask.Combine();
ProfileClient profilesws = new ProfileClient();
var profileRecords = profilesws.GetAllProfiles();
var tasks = new List <Task <ResultClass> >();
foreach (var profile in profileRecords.ProfileRecords)
{
var testProfile = new NewTask.Profile();
testProfile.Id = profile.Id;
testProfile.Name = profile.Name;
tasks.Add(taskcombine.TestProfileAsync(testProfile))
}
int completedIndex = Task.WaitAny(tasks.ToArray());
var result = tasks[completedIndex].Result;
profilesws.Close();
taskcombine.Close();
}
public async Task EnablePaymentMethodAsync_WhenEnablingPaymentMethodForProfile_PaymentMethodIsReturned()
{
// Given: We retrieve the profile from the API
ProfileClient profileClient = new ProfileClient("abcde"); // Set access token
ListResponse <ProfileResponse> allProfiles = await profileClient.GetProfileListAsync();
if (allProfiles.Items.Count == 0)
{
Assert.Inconclusive("No profiles found. Unable to continue test");
}
ProfileResponse profileToTestWith = allProfiles.Items.First();
// When: We enable a payment method for the given profile
PaymentMethodResponse paymentMethodResponse = await profileClient.EnablePaymentMethodAsync(profileToTestWith.Id, PaymentMethod.Ideal);
// Then: Make sure a payment method is returned
Assert.IsNotNull(paymentMethodResponse);
Assert.AreEqual(PaymentMethod.Ideal, paymentMethodResponse.Id);
}
public ProfileClientFixture()
{
HttpClientFactory = new Mock <HttpClientFactory>(new Mock <IDependencyResolver>().Object);
HttpClientFactory.Setup(p => p.Create()).Returns(() =>
{
return(new HttpClient());
});
BaasicClientFactory = new Mock <IBaasicClientFactory>();
BaasicClientFactory.Setup(f => f.Create(It.IsAny <IClientConfiguration>())).Returns((IClientConfiguration config) => new BaasicClient(config, HttpClientFactory.Object, new JsonFormatter()));
ClientConfiguration = new Mock <IClientConfiguration>();
ClientConfiguration.Setup(p => p.DefaultMediaType).Returns(Baasic.Client.Configuration.ClientConfiguration.HalJsonMediaType);
ClientConfiguration.Setup(p => p.DefaultTimeout).Returns(TimeSpan.FromSeconds(1));
ClientConfiguration.Setup(p => p.ApplicationIdentifier).Returns("Test");
ClientConfiguration.Setup(p => p.SecureBaseAddress).Returns("https://api.baasic.com/v1");
ClientConfiguration.Setup(p => p.BaseAddress).Returns("http://api.baasic.com/v1");
Target = new ProfileClient(this.ClientConfiguration.Object, this.BaasicClientFactory.Object);
}
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 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
};
}
private void InitializeAzureProfile(AzureProfile profile, string parameterSet, AzureProfileSettings settings)
{
var profileClient = new ProfileClient(profile);
if (settings.Environment == null)
{
settings.Environment = AzureEnvironment.PublicEnvironments["AzureCloud"];
}
switch (parameterSet)
{
case CertificateParameterSet:
profileClient.InitializeProfile(settings.Environment, new Guid(settings.SubscriptionId), settings.Certificate,
settings.StorageAccount);
break;
case CredentialsParameterSet:
var userAccount = new AzureAccount
{
Id = settings.Credential.UserName,
Type = AzureAccount.AccountType.User
};
profileClient.InitializeProfile(settings.Environment, new Guid(settings.SubscriptionId), userAccount,
settings.Credential.Password, settings.StorageAccount);
break;
case AccessTokenParameterSet:
profileClient.InitializeProfile(settings.Environment, new Guid(settings.SubscriptionId), settings.AccessToken,
settings.AccountId, settings.StorageAccount);
break;
case ServicePrincipalParameterSet:
var servicePrincipalAccount = new AzureAccount
{
Id = settings.Credential.UserName,
Type = AzureAccount.AccountType.ServicePrincipal
};
profileClient.InitializeProfile(settings.Environment, new Guid(settings.SubscriptionId), servicePrincipalAccount,
settings.Credential.Password, settings.StorageAccount);
break;
}
}
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(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
AzureEnvironment env = client.Profile.Environments["KaTaL"];
Assert.Equal(env.Name, cmdlet.Name);
Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], cmdlet.PublishSettingsFileUrl);
}
/// <summary>
/// TODO: Migrate all code that references this method to use AzureContext
/// </summary>
/// <typeparam name="TClient"></typeparam>
/// <param name="subscription"></param>
/// <param name="endpoint"></param>
/// <returns></returns>
public virtual TClient CreateClient <TClient>(AzureProfile profile, AzureSubscription subscription, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient>
{
if (subscription == null)
{
throw new ApplicationException(Resources.InvalidDefaultSubscription);
}
ProfileClient profileClient = new ProfileClient(profile);
AzureContext context = new AzureContext(subscription,
profileClient.GetAccount(subscription.Account),
profileClient.GetEnvironmentOrDefault(subscription.Environment));
TClient client = CreateClient <TClient>(context, endpoint);
foreach (IClientAction action in actions.Values)
{
action.Apply <TClient>(client, profile, endpoint);
}
return(client);
}
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
}
}
}
public TClient CreateClient <TClient>(AzureSubscription subscription, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient>
{
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription.Id.ToString(), "fake_token");
if (HttpMockServer.GetCurrentMode() != HttpRecorderMode.Playback)
{
ProfileClient profileClient = new ProfileClient();
AzureContext context = new AzureContext()
{
Account = profileClient.GetAccount(subscription.Account),
Environment = profileClient.GetEnvironmentOrDefault(subscription.Environment),
Subscription = subscription
};
creds = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
}
Uri endpointUri = (new ProfileClient()).Profile.Environments[subscription.Environment].GetEndpointAsUri(endpoint);
return(CreateCustomClient <TClient>(creds, endpointUri));
}
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 void SetAzureSubscriptionUpdatesSubscriptionWithCertificate()
{
SetAzureSubscriptionCommand cmdlt = new SetAzureSubscriptionCommand();
// Setup
ProfileClient client = new ProfileClient();
client.AddOrSetAccount(azureAccount);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
client.Profile.Save();
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.SubscriptionId = azureSubscription1.Id.ToString();
cmdlt.CurrentStorageAccountName = "NewCloudStorage";
cmdlt.Certificate = SampleCertificate;
// Act
cmdlt.InvokeBeginProcessing();
cmdlt.ExecuteCmdlet();
cmdlt.InvokeEndProcessing();
// Verify
client = new ProfileClient();
var newSubscription = client.Profile.Subscriptions[new Guid(cmdlt.SubscriptionId)];
var newAccount = client.Profile.Accounts[SampleCertificate.Thumbprint];
var existingAccount = client.Profile.Accounts[azureAccount.Id];
Assert.Equal(azureEnvironment.Name, newSubscription.Environment);
Assert.Equal(cmdlt.CurrentStorageAccountName, newSubscription.GetProperty(AzureSubscription.Property.StorageAccount));
Assert.Equal(newAccount.Id, newSubscription.Account);
Assert.Equal(AzureAccount.AccountType.Certificate, newAccount.Type);
Assert.Equal(SampleCertificate.Thumbprint, newAccount.Id);
Assert.Equal(cmdlt.SubscriptionId, newAccount.GetProperty(AzureAccount.Property.Subscriptions));
Assert.Equal(azureAccount.Id, existingAccount.Id);
Assert.Equal(AzureAccount.AccountType.User, existingAccount.Type);
Assert.True(existingAccount.GetPropertyAsArray(AzureAccount.Property.Subscriptions).Contains(cmdlt.SubscriptionId));
}
public EnvironmentSetupHelper()
{
var datastore = new MemoryDataStore();
AzureSession.DataStore = datastore;
var profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
AzureSMCmdlet.CurrentProfile = profile;
AzureSession.DataStore = datastore;
ProfileClient = new ProfileClient(profile);
// Ignore SSL errors
System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true;
// Set RunningMocked
if (HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback)
{
TestMockSupport.RunningMocked = true;
}
else
{
TestMockSupport.RunningMocked = false;
}
}
private PSAzureSubscriptionExtended ConstructPsAzureSubscriptionExtended(AzureSubscription subscription, IClientFactory clientFactory)
{
using (var client = clientFactory.CreateClient <ManagementClient>(Profile, subscription, AzureEnvironment.Endpoint.ServiceManagement))
{
var response = client.Subscriptions.Get();
var environment = ProfileClient.GetEnvironmentOrDefault(subscription.Environment);
var account = ProfileClient.Profile.Accounts[subscription.Account];
bool isCert = account.Type == AzureAccount.AccountType.Certificate;
var psAzureSubscription = new PSAzureSubscription(subscription, ProfileClient.Profile);
PSAzureSubscriptionExtended result = new PSAzureSubscriptionExtended(psAzureSubscription)
{
AccountAdminLiveEmailId = response.AccountAdminLiveEmailId,
ActiveDirectoryUserId = subscription.Account,
CurrentCoreCount = response.CurrentCoreCount,
CurrentHostedServices = response.CurrentHostedServices,
CurrentDnsServers = response.CurrentDnsServers,
CurrentLocalNetworkSites = response.CurrentLocalNetworkSites,
CurrentStorageAccounts = response.CurrentStorageAccounts,
CurrentVirtualNetworkSites = response.CurrentVirtualNetworkSites,
MaxCoreCount = response.MaximumCoreCount,
MaxDnsServers = response.MaximumDnsServers,
MaxHostedServices = response.MaximumHostedServices,
MaxLocalNetworkSites = response.MaximumLocalNetworkSites,
MaxStorageAccounts = response.MaximumStorageAccounts,
MaxVirtualNetworkSites = response.MaximumVirtualNetworkSites,
ServiceAdminLiveEmailId = response.ServiceAdminLiveEmailId,
SubscriptionRealName = response.SubscriptionName,
SubscriptionStatus = response.SubscriptionStatus.ToString(),
ServiceEndpoint = environment.GetEndpoint(AzureEnvironment.Endpoint.ServiceManagement),
ResourceManagerEndpoint = environment.GetEndpoint(AzureEnvironment.Endpoint.ResourceManager),
IsDefault = subscription.GetProperty(AzureSubscription.Property.Default) != null,
Account = account,
Certificate = isCert ? AzureSession.DataStore.GetCertificate(subscription.Account) : null,
CurrentStorageAccountName = subscription.GetProperty(AzureSubscription.Property.StorageAccount)
};
return(result);
}
}
private async Task InitViewBag()
{
ViewBag.ConnectUrls = GetFederationManagementUrls(ViewBag.Claims, ManagementDisconnectedAccountType, "connect");
ViewBag.DisconnectUrls = GetFederationManagementUrls(ViewBag.Claims, ManagementConnectedAccountType, "disconnect");
try
{
var claims = await ProfileClient.GetClaims(User.Identity.GetUserId());
var profile = new UpdateProfileClaimsViewModel
{
Name = claims.FirstOrDefault(x => x.Type == Common.Consts.DefaultClaimNamespace + "name")?.Value ?? "",
Address = claims.FirstOrDefault(x => x.Type == Common.Consts.DefaultClaimNamespace + "address")?.Value ?? ""
};
ViewBag.Profile = profile;
}
catch (ApiException)
{
ViewBag.Profile = new UpdateProfileClaimsViewModel {
Address = "", Name = ""
};
}
}
public override void ExecuteCmdlet()
{
switch (ParameterSetName)
{
case "ByName":
WriteSubscriptions(ProfileClient.RefreshSubscriptions(AzureSession.CurrentContext.Environment)
.Where(s => SubscriptionName == null || s.Name.Equals(SubscriptionName, StringComparison.InvariantCultureIgnoreCase)));
break;
case "ById":
WriteSubscriptions(ProfileClient.GetSubscription(new Guid(SubscriptionId)));
break;
case "Default":
GetDefault();
break;
case "Current":
GetCurrent();
break;
}
}
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>
/// 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 ImportPublishSettingsFileOverwritesEnvironment()
{
ImportAzurePublishSettingsCommand cmdlt = new ImportAzurePublishSettingsCommand();
// Setup
ProfileClient.DataStore.WriteFile("ImportPublishSettingsFileSelectsCorrectEnvironment.publishsettings",
Properties.Resources.ValidProfileChina);
ProfileClient client = new ProfileClient();
var oldDataStore = FileUtilities.DataStore;
FileUtilities.DataStore = ProfileClient.DataStore;
var expectedEnv = "AzureCloud";
var expected = client.ImportPublishSettings("ImportPublishSettingsFileSelectsCorrectEnvironment.publishsettings", expectedEnv);
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.ProfileClient = new ProfileClient();
cmdlt.PublishSettingsFile = "ImportPublishSettingsFileSelectsCorrectEnvironment.publishsettings";
cmdlt.Environment = expectedEnv;
try
{
// Act
cmdlt.InvokeBeginProcessing();
cmdlt.ExecuteCmdlet();
cmdlt.InvokeEndProcessing();
// Verify
foreach (var subscription in expected)
{
Assert.Equal(cmdlt.ProfileClient.GetSubscription(subscription.Id).Environment, expectedEnv);
}
commandRuntimeMock.Verify(f => f.WriteObject(expected), Times.Once());
}
finally
{
// Cleanup
FileUtilities.DataStore = oldDataStore;
}
}
public void SetAzureSubscriptionUpdatesSubscriptionWithCertificate()
{
SetAzureSubscriptionCommand cmdlt = new SetAzureSubscriptionCommand();
// Setup
ProfileClient client = new ProfileClient();
client.AddOrSetAccount(azureAccount);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
client.Profile.Save();
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.SubscriptionId = azureSubscription1.Id.ToString();
cmdlt.CurrentStorageAccountName = "NewCloudStorage";
cmdlt.Certificate = SampleCertificate;
// Act
cmdlt.InvokeBeginProcessing();
cmdlt.ExecuteCmdlet();
cmdlt.InvokeEndProcessing();
// Verify
client = new ProfileClient();
var newSubscription = client.Profile.Subscriptions[new Guid(cmdlt.SubscriptionId)];
var newAccount = client.Profile.Accounts[SampleCertificate.Thumbprint];
var existingAccount = client.Profile.Accounts[azureAccount.Id];
Assert.Equal(azureEnvironment.Name, newSubscription.Environment);
Assert.Equal(cmdlt.CurrentStorageAccountName, newSubscription.GetProperty(AzureSubscription.Property.StorageAccount));
Assert.Equal(newAccount.Id, newSubscription.Account);
Assert.Equal(AzureAccount.AccountType.Certificate, newAccount.Type);
Assert.Equal(SampleCertificate.Thumbprint, newAccount.Id);
Assert.Equal(cmdlt.SubscriptionId, newAccount.GetProperty(AzureAccount.Property.Subscriptions));
Assert.Equal(azureAccount.Id, existingAccount.Id);
Assert.Equal(AzureAccount.AccountType.User, existingAccount.Type);
Assert.True(existingAccount.GetPropertyAsArray(AzureAccount.Property.Subscriptions).Contains(cmdlt.SubscriptionId));
}
public void SetAzureSubscriptionDerivesEnvironmentFromBothEndpointParameters()
{
SetAzureSubscriptionCommand cmdlt = new SetAzureSubscriptionCommand();
// Setup
ProfileClient client = new ProfileClient();
client.AddOrSetAccount(azureAccount);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
client.Profile.Save();
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.SubscriptionId = azureSubscription1.Id.ToString();
cmdlt.CurrentStorageAccountName = "NewCloudStorage";
cmdlt.ServiceEndpoint = azureEnvironment.GetEndpoint(AzureEnvironment.Endpoint.ServiceManagement);
cmdlt.ResourceManagerEndpoint = azureEnvironment.GetEndpoint(AzureEnvironment.Endpoint.ResourceManager);
// Act
cmdlt.InvokeBeginProcessing();
cmdlt.ExecuteCmdlet();
cmdlt.InvokeEndProcessing();
// Verify
client = new ProfileClient();
var newSubscription = client.Profile.Subscriptions[new Guid(cmdlt.SubscriptionId)];
Assert.Equal(cmdlt.Environment, newSubscription.Environment);
Assert.Equal(cmdlt.CurrentStorageAccountName, newSubscription.GetProperty(AzureSubscription.Property.StorageAccount));
}
public void SetAzureSubscriptionThrowsExceptionWithoutCertificateOnAdd()
{
SetAzureSubscriptionCommand cmdlt = new SetAzureSubscriptionCommand();
// Setup
ProfileClient client = new ProfileClient();
client.AddOrSetEnvironment(azureEnvironment);
client.Profile.Save();
cmdlt.CommandRuntime = commandRuntimeMock.Object;
cmdlt.SubscriptionId = Guid.NewGuid().ToString();
cmdlt.SubscriptionName = "NewSubscriptionName";
cmdlt.CurrentStorageAccountName = "NewCloudStorage";
cmdlt.Environment = azureEnvironment.Name;
// Verify
cmdlt.InvokeBeginProcessing();
Assert.Throws<ArgumentException>(()=> cmdlt.ExecuteCmdlet());
}
/// <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)
{
var profileClient = new ProfileClient(Profile);
environment = profileClient.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) || Context != null)
{
ProfileClient.GetAccount(subscription.Account);
if (Profile.Context != null && Profile.Context.Subscription != null &&
Profile.Context.Subscription.Id == subscription.Id)
{
GeneralUtilities.ClearCurrentStorageAccount();
}
var context = new AzureContext(subscription, ProfileClient.GetAccount(subscription.Account), ProfileClient.GetEnvironmentOrDefault(subscription.Environment));
if (Context != null)
{
context.SetCurrentStorageAccount(this);
}
else
{
var client = AzureSession.ClientFactory.CreateClient<StorageManagementClient>(context,
AzureEnvironment.Endpoint.ServiceManagement);
var account = StorageUtilities.GenerateCloudStorageAccount(client, CurrentStorageAccountName);
context.SetCurrentStorageAccount(account.ToString(true));
}
}
subscription = ProfileClient.AddOrSetSubscription(subscription);
if (PassThru)
{
WriteObject(subscription);
}
}