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));
}
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 BaseSetup()
{
if (AzureSession.DataStore != null && !(AzureSession.DataStore is MemoryDataStore))
{
AzureSession.DataStore = new MemoryDataStore();
}
currentProfile = new AzureSMProfile();
if (currentProfile.Context.Subscription == null)
{
var newGuid = Guid.NewGuid();
var client = new ProfileClient(currentProfile);
client.AddOrSetAccount(new AzureAccount
{
Id = "test",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, newGuid.ToString()}
}
});
client.AddOrSetSubscription( new AzureSubscription { Id = newGuid, Name = "test", Environment = EnvironmentName.AzureCloud, Account = "test" });
client.SetSubscriptionAsDefault(newGuid, "test");
}
AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory();
}
protected override void BeginProcessing()
{
base.BeginProcessing();
ProfileClient = new ProfileClient(Profile);
ProfileClient.WarningLog = WriteWarning;
ProfileClient.DebugLog = WriteDebug;
}
public void NewProfileFromCertificateWithNullsThrowsArgumentNullException()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
AzureProfile newProfile = new AzureProfile();
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 void ProfileMigratesOldData()
{
MemoryDataStore dataStore = new MemoryDataStore();
dataStore.VirtualStore[oldProfileDataPath] = oldProfileData;
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
Assert.False(dataStore.FileExists(oldProfileDataPath));
Assert.True(dataStore.FileExists(newProfileDataPath));
}
public void ProfileSerializeDeserializeWorks()
{
var dataStore = new MockDataStore();
var currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
AzureSession.DataStore = dataStore;
var client = new ProfileClient(currentProfile);
var tenant = Guid.NewGuid().ToString();
var environment = new AzureEnvironment
{
Name = "testCloud",
Endpoints = { { AzureEnvironment.Endpoint.ActiveDirectory, "http://contoso.com" } }
};
var account = new AzureAccount
{
Id = "*****@*****.**",
Type = AzureAccount.AccountType.User,
Properties = { { AzureAccount.Property.Tenants, tenant } }
};
var sub = new AzureSubscription
{
Account = account.Id,
Environment = environment.Name,
Id = new Guid(),
Name = "Contoso Test Subscription",
Properties = { { AzureSubscription.Property.Tenants, tenant } }
};
client.AddOrSetEnvironment(environment);
client.AddOrSetAccount(account);
client.AddOrSetSubscription(sub);
AzureProfile deserializedProfile;
// Round-trip the exception: Serialize and de-serialize with a BinaryFormatter
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
// "Save" object state
bf.Serialize(ms, currentProfile);
// Re-use the same stream for de-serialization
ms.Seek(0, 0);
// Replace the original exception with de-serialized one
deserializedProfile = (AzureProfile)bf.Deserialize(ms);
}
Assert.NotNull(deserializedProfile);
var jCurrentProfile = JsonConvert.SerializeObject(currentProfile);
var jDeserializedProfile = JsonConvert.SerializeObject(deserializedProfile);
Assert.Equal(jCurrentProfile, jDeserializedProfile);
}
public void ProfileSaveDoesNotSerializeContext()
{
var dataStore = new MockDataStore();
var currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
AzureSession.DataStore = dataStore;
var client = new ProfileClient(currentProfile);
var tenant = Guid.NewGuid().ToString();
var environment = new AzureEnvironment
{
Name = "testCloud",
Endpoints = { { AzureEnvironment.Endpoint.ActiveDirectory, "http://contoso.com" } }
};
var account = new AzureAccount
{
Id = "*****@*****.**",
Type = AzureAccount.AccountType.User,
Properties = { { AzureAccount.Property.Tenants, tenant } }
};
var sub = new AzureSubscription
{
Account = account.Id,
Environment = environment.Name,
Id = new Guid(),
Name = "Contoso Test Subscription",
Properties = { { AzureSubscription.Property.Tenants, tenant } }
};
client.AddOrSetEnvironment(environment);
client.AddOrSetAccount(account);
client.AddOrSetSubscription(sub);
currentProfile.Save();
var profileFile = currentProfile.ProfilePath;
string profileContents = dataStore.ReadFileAsText(profileFile);
var readProfile = JsonConvert.DeserializeObject<Dictionary<string, object>>(profileContents);
Assert.False(readProfile.ContainsKey("Context"));
AzureProfile parsedProfile = new AzureProfile();
var serializer = new JsonProfileSerializer();
Assert.True(serializer.Deserialize(profileContents, parsedProfile));
Assert.NotNull(parsedProfile);
Assert.NotNull(parsedProfile.Environments);
Assert.True(parsedProfile.Environments.ContainsKey(environment.Name));
Assert.NotNull(parsedProfile.Accounts);
Assert.True(parsedProfile.Accounts.ContainsKey(account.Id));
Assert.NotNull(parsedProfile.Subscriptions);
Assert.True(parsedProfile.Subscriptions.ContainsKey(sub.Id));
}
// 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;
}
public static IHDInsightSubscriptionCredentials GetAccessTokenCredentials(this IAzureHDInsightCommonCommandBase command,
AzureSubscription currentSubscription, AzureAccount azureAccount, AzureEnvironment environment)
{
ProfileClient profileClient = new ProfileClient(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
AzureContext azureContext = new AzureContext(currentSubscription, azureAccount, environment);
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 RefreshSubscriptionsUpdatesAccounts()
{
SetMocks(new[] { rdfeSubscription1, rdfeSubscription2 }.ToList(), new[] { csmSubscription1, csmSubscription1withDuplicateId }.ToList());
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.AddOrSetEnvironment(azureEnvironment);
client.Profile.Accounts[azureAccount.Id] = azureAccount;
client.AddOrSetSubscription(azureSubscription1);
var subscriptions = client.RefreshSubscriptions(azureEnvironment);
Assert.True(client.Profile.Accounts[azureAccount.Id].HasSubscription(new Guid(rdfeSubscription1.SubscriptionId)));
Assert.True(client.Profile.Accounts[azureAccount.Id].HasSubscription(new Guid(rdfeSubscription2.SubscriptionId)));
Assert.True(client.Profile.Accounts[azureAccount.Id].HasSubscription(new Guid(csmSubscription1.SubscriptionId)));
Assert.True(client.Profile.Accounts[azureAccount.Id].HasSubscription(new Guid(csmSubscription1withDuplicateId.SubscriptionId)));
}
public void RemoveAzureSubscriptionChecksAndRemoves()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Accounts[azureAccount.Id] = azureAccount;
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
client.SetSubscriptionAsDefault(azureSubscription1.Name, azureSubscription1.Account);
Assert.Equal(1, client.Profile.Subscriptions.Count);
List<string> log = new List<string>();
client.WarningLog = log.Add;
var subscription = client.RemoveSubscription(azureSubscription1.Name);
Assert.Equal(0, client.Profile.Subscriptions.Count);
Assert.Equal(azureSubscription1.Name, subscription.Name);
Assert.Equal(1, log.Count);
Assert.Equal(
"The default subscription is being removed. Use Select-AzureSubscription -Default <subscriptionName> to select a new default subscription.",
log[0]);
Assert.Throws<ArgumentException>(() => client.RemoveSubscription("bad"));
Assert.Throws<ArgumentNullException>(() => client.RemoveSubscription(null));
}
public void AddOrSetAzureSubscriptionUpdatesInMemory()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
ProfileClient client = new ProfileClient(currentProfile);
client.AddOrSetAccount(azureAccount);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
currentProfile.DefaultSubscription = azureSubscription1;
azureSubscription1.Properties[AzureSubscription.Property.StorageAccount] = "testAccount";
Assert.Equal(azureSubscription1.Id, currentProfile.Context.Subscription.Id);
Assert.Equal(azureSubscription1.Properties[AzureSubscription.Property.StorageAccount],
currentProfile.Context.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, currentProfile.Context.Subscription.Id);
Assert.Equal(newSubscription.Id, newSubscriptionFromProfile.Id);
Assert.Equal(newSubscription.Properties[AzureSubscription.Property.StorageAccount],
currentProfile.Context.Subscription.Properties[AzureSubscription.Property.StorageAccount]);
Assert.Equal(newSubscription.Properties[AzureSubscription.Property.StorageAccount],
newSubscriptionFromProfile.Properties[AzureSubscription.Property.StorageAccount]);
}
public void NewProfileFromCertificateReturnsProfile()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
AzureProfile newProfile = new AzureProfile();
ProfileClient client1 = new ProfileClient(newProfile);
var subscriptionId = Guid.NewGuid();
var certificate = new X509Certificate2(Convert.FromBase64String(dummyCertificate));
client1.InitializeProfile(AzureEnvironment.PublicEnvironments["AzureCloud"],
subscriptionId, certificate, null);
Assert.Equal("AzureCloud", newProfile.DefaultSubscription.Environment);
Assert.Equal(subscriptionId, newProfile.DefaultSubscription.Id);
Assert.Equal(certificate.Thumbprint, newProfile.DefaultSubscription.Account);
Assert.False(newProfile.DefaultSubscription.Properties.ContainsKey(AzureSubscription.Property.StorageAccount));
}
public void AddOrSetAzureSubscriptionChecksAndUpdates()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.AddOrSetAccount(azureAccount);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetSubscription(azureSubscription1);
Assert.Equal(1, client.Profile.Subscriptions.Count);
var subscription = client.AddOrSetSubscription(azureSubscription1);
Assert.Equal(1, client.Profile.Subscriptions.Count);
Assert.Equal(1, client.Profile.Accounts.Count);
Assert.Equal(subscription, azureSubscription1);
Assert.Throws<ArgumentNullException>(() => client.AddOrSetSubscription(null));
Assert.Throws<ArgumentNullException>(() => client.AddOrSetSubscription(
new AzureSubscription { Id = new Guid(), Environment = null, Name = "foo" }));
}
public void RemoveAzureAccountRemovesInMemoryAccount()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Subscriptions[azureSubscription1.Id] = azureSubscription1;
client.Profile.Subscriptions[azureSubscription2.Id] = azureSubscription2;
client.Profile.Accounts[azureAccount.Id] = azureAccount;
azureSubscription3withoutUser.Account = "test2";
client.Profile.Accounts["test2"] = new AzureAccount
{
Id = "test2",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, azureSubscription1.Id.ToString()}
}
};
client.Profile.Subscriptions[azureSubscription1.Id].Account = azureAccount.Id;
client.Profile.Environments[azureEnvironment.Name] = azureEnvironment;
currentProfile.DefaultSubscription = azureSubscription1;
client.RemoveAccount(azureAccount.Id);
Assert.Equal("test2", currentProfile.Context.Account.Id);
Assert.Equal("test2", currentProfile.Context.Subscription.Account);
Assert.Equal(azureSubscription1.Id, currentProfile.Context.Subscription.Id);
client.RemoveAccount("test2");
Assert.Null(currentProfile.Context.Account);
Assert.Null(currentProfile.Context.Subscription);
Assert.Null(currentProfile.Context.Environment);
}
public void RemoveAzureAccountRemovesSubscriptions()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Subscriptions[azureSubscription1.Id] = azureSubscription1;
client.Profile.Subscriptions[azureSubscription2.Id] = azureSubscription2;
client.Profile.Accounts[azureAccount.Id] = azureAccount;
azureSubscription3withoutUser.Account = "test2";
client.Profile.Accounts["test2"] = new AzureAccount
{
Id = "test2",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, azureSubscription3withoutUser.Id.ToString()}
}
};
client.Profile.Subscriptions[azureSubscription3withoutUser.Id] = azureSubscription3withoutUser;
client.Profile.Environments[azureEnvironment.Name] = azureEnvironment;
List<string> log = new List<string>();
client.WarningLog = log.Add;
Assert.Equal(3, client.Profile.Subscriptions.Count);
client.RemoveAccount("test2");
Assert.Equal(2, client.Profile.Subscriptions.Count);
Assert.Equal(0, log.Count);
}
/// <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))
{
subscription.Properties[AzureSubscription.Property.StorageAccount] = CurrentStorageAccountName;
}
subscription = ProfileClient.AddOrSetSubscription(subscription);
if (PassThru)
{
WriteObject(subscription);
}
}
public void RemoveAzureAccountRemovesDefaultSubscriptionAndWritesWarning()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Subscriptions[azureSubscription1.Id] = azureSubscription1;
client.Profile.Subscriptions[azureSubscription2.Id] = azureSubscription2;
client.Profile.Accounts[azureAccount.Id] = azureAccount;
azureSubscription3withoutUser.Account = "test2";
client.Profile.Accounts["test2"] = new AzureAccount
{
Id = "test2",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, azureSubscription3withoutUser.Id.ToString()}
}
};
client.Profile.Subscriptions[azureSubscription3withoutUser.Id] = azureSubscription3withoutUser;
client.Profile.Environments[azureEnvironment.Name] = azureEnvironment;
List<string> log = new List<string>();
client.WarningLog = log.Add;
Assert.Equal(3, client.Profile.Subscriptions.Count);
var account = client.RemoveAccount("test");
Assert.Equal(1, client.Profile.Subscriptions.Count);
Assert.Equal("test", account.Id);
Assert.Equal(2, account.GetPropertyAsArray(AzureAccount.Property.Subscriptions).Length);
Assert.Equal(1, log.Count);
Assert.Equal(
"The default subscription is being removed. Use Select-AzureSubscription -Default <subscriptionName> to select a new default subscription.",
log[0]);
}
public void GetAzureEnvironmentsListsEnvironments()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
var env1 = client.ListEnvironments(null);
Assert.Equal(2, env1.Count);
var env2 = client.ListEnvironments("bad");
Assert.Equal(0, env2.Count);
var env3 = client.ListEnvironments(EnvironmentName.AzureCloud);
Assert.Equal(1, env3.Count);
}
public void AddAzureEnvironmentAddsEnvironment()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
Assert.Equal(2, client.Profile.Environments.Count);
Assert.Throws<ArgumentNullException>(() => client.AddOrSetEnvironment(null));
var env = client.AddOrSetEnvironment(azureEnvironment);
Assert.Equal(3, client.Profile.Environments.Count);
Assert.Equal(env, azureEnvironment);
}
public void RefreshSubscriptionsMergesFromServer()
{
SetMocks(new[] { rdfeSubscription1, rdfeSubscription2 }.ToList(), new[] { csmSubscription1, csmSubscription1withDuplicateId }.ToList());
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.AddOrSetEnvironment(azureEnvironment);
client.Profile.Accounts[azureAccount.Id] = azureAccount;
client.AddOrSetSubscription(azureSubscription1);
var subscriptions = client.RefreshSubscriptions(azureEnvironment);
Assert.Equal(4, subscriptions.Count);
Assert.Equal(4, subscriptions.Count(s => s.Account == "test"));
Assert.Equal(1, subscriptions.Count(s => s.Id == azureSubscription1.Id));
Assert.Equal(1, subscriptions.Count(s => s.Id == new Guid(rdfeSubscription1.SubscriptionId)));
Assert.Equal(2, subscriptions.First(s => s.Id == new Guid(rdfeSubscription1.SubscriptionId)).GetPropertyAsArray(AzureSubscription.Property.SupportedModes).Count());
Assert.Equal(1, subscriptions.Count(s => s.Id == new Guid(rdfeSubscription2.SubscriptionId)));
Assert.Equal(1, subscriptions.Count(s => s.Id == new Guid(csmSubscription1.SubscriptionId)));
}
public void GetAzureEnvironmentReturnsCorrectValue()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
ProfileClient client = new ProfileClient(currentProfile);
client.AddOrSetEnvironment(azureEnvironment);
var defaultEnv = client.GetEnvironmentOrDefault(null);
Assert.Equal(EnvironmentName.AzureCloud, defaultEnv.Name);
var newEnv = client.GetEnvironmentOrDefault(azureEnvironment.Name);
Assert.Equal(azureEnvironment.Name, newEnv.Name);
Assert.Throws<ArgumentException>(() => client.GetEnvironmentOrDefault("bad"));
}
public void GetAzureAccountReturnsAllAccountsWithNullUser()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Subscriptions[azureSubscription1.Id] = azureSubscription1;
client.Profile.Subscriptions[azureSubscription2.Id] = azureSubscription2;
client.Profile.Accounts[azureAccount.Id] = azureAccount;
azureSubscription3withoutUser.Account = "test2";
client.Profile.Accounts["test2"] = new AzureAccount
{
Id = "test2",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, azureSubscription3withoutUser.Id.ToString()}
}
};
client.Profile.Subscriptions[azureSubscription3withoutUser.Id] = azureSubscription3withoutUser;
client.Profile.Environments[azureEnvironment.Name] = azureEnvironment;
var account = client.ListAccounts(null).ToList();
Assert.Equal(2, account.Count);
}
public void GetCurrentEnvironmentReturnsCorrectValue()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
ProfileClient client = new ProfileClient(currentProfile);
client.AddOrSetEnvironment(azureEnvironment);
client.AddOrSetAccount(azureAccount);
client.AddOrSetSubscription(azureSubscription1);
currentProfile.DefaultSubscription = azureSubscription1;
var newEnv = client.GetEnvironmentOrDefault(azureEnvironment.Name);
Assert.Equal(azureEnvironment.Name, newEnv.Name);
}
public void RemoveAzureEnvironmentRemovesEnvironmentSubscriptionsAndAccounts()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Accounts[azureAccount.Id] = azureAccount;
client.Profile.Environments[azureEnvironment.Name] = azureEnvironment;
client.Profile.Subscriptions[azureSubscription1.Id] = azureSubscription1;
client.Profile.Subscriptions[azureSubscription2.Id] = azureSubscription2;
Assert.Equal(2, client.Profile.Subscriptions.Values.Count(s => s.Environment == "Test"));
Assert.Equal(3, client.Profile.Environments.Count);
Assert.Equal(1, client.Profile.Accounts.Count);
Assert.Throws<ArgumentNullException>(() => client.RemoveEnvironment(null));
Assert.Throws<ArgumentException>(() => client.RemoveEnvironment("bad"));
var env = client.RemoveEnvironment(azureEnvironment.Name);
Assert.Equal(azureEnvironment.Name, env.Name);
Assert.Equal(0, client.Profile.Subscriptions.Values.Count(s => s.Environment == "Test"));
Assert.Equal(2, client.Profile.Environments.Count);
Assert.Equal(0, client.Profile.Accounts.Count);
}
public void RemoveAzureAccountRemovesDefaultAccountFromSubscription()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Subscriptions[azureSubscription1.Id] = azureSubscription1;
client.Profile.Subscriptions[azureSubscription2.Id] = azureSubscription2;
client.Profile.Accounts[azureAccount.Id] = azureAccount;
azureSubscription3withoutUser.Account = "test2";
client.Profile.Accounts["test2"] = new AzureAccount
{
Id = "test2",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, azureSubscription1.Id.ToString()}
}
};
client.Profile.Subscriptions[azureSubscription1.Id].Account = azureAccount.Id;
client.Profile.Environments[azureEnvironment.Name] = azureEnvironment;
var account = client.RemoveAccount(azureAccount.Id);
Assert.Equal("test2", client.Profile.Subscriptions[azureSubscription1.Id].Account);
}
private void InitializeAzureProfile(AzureProfile profile, string parameterSet, AzureProfileSettings settings)
{
var savedCache = AzureSession.TokenCache;
AzureSession.TokenCache = DefaultMemoryTokenCache;
try
{
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,
};
servicePrincipalAccount.SetOrAppendProperty(AzureAccount.Property.Tenants, settings.Tenant);
profileClient.InitializeProfile(settings.Environment, new Guid(settings.SubscriptionId),
servicePrincipalAccount,
settings.Credential.Password, settings.StorageAccount);
break;
case EmptyParameterSet:
if (!profile.Environments.ContainsKey(settings.Environment.Name))
{
profile.Environments.Add(settings.Environment.Name, settings.Environment);
}
break;
}
}
finally
{
AzureSession.TokenCache = savedCache;
}
}
public void RemoveAzureEnvironmentDoesNotRemoveEnvironmentSubscriptionsAndAccountsForAzureCloudOrChinaCloud()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
client.Profile.Accounts[azureAccount.Id] = azureAccount;
azureSubscription1.Environment = EnvironmentName.AzureCloud;
azureSubscription2.Environment = EnvironmentName.AzureChinaCloud;
client.Profile.Subscriptions[azureSubscription1.Id] = azureSubscription1;
client.Profile.Subscriptions[azureSubscription2.Id] = azureSubscription2;
Assert.Equal(1, client.Profile.Subscriptions.Values.Count(s => s.Environment == EnvironmentName.AzureCloud));
Assert.Equal(1, client.Profile.Subscriptions.Values.Count(s => s.Environment == EnvironmentName.AzureChinaCloud));
Assert.Equal(2, client.Profile.Environments.Count);
Assert.Equal(1, client.Profile.Accounts.Count);
Assert.Throws<ArgumentException>(() => client.RemoveEnvironment(EnvironmentName.AzureCloud));
Assert.Throws<ArgumentException>(() => client.RemoveEnvironment(EnvironmentName.AzureChinaCloud));
Assert.Equal(1, client.Profile.Subscriptions.Values.Count(s => s.Environment == EnvironmentName.AzureCloud));
Assert.Equal(1, client.Profile.Subscriptions.Values.Count(s => s.Environment == EnvironmentName.AzureChinaCloud));
Assert.Equal(2, client.Profile.Environments.Count);
Assert.Equal(1, client.Profile.Accounts.Count);
}
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 SetAzureEnvironmentUpdatesEnvironment()
{
MemoryDataStore dataStore = new MemoryDataStore();
AzureSession.DataStore = dataStore;
currentProfile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
ProfileClient client = new ProfileClient(currentProfile);
Assert.Equal(2, client.Profile.Environments.Count);
Assert.Throws<ArgumentNullException>(() => client.AddOrSetEnvironment(null));
var env2 = client.AddOrSetEnvironment(azureEnvironment);
Assert.Equal(env2.Name, azureEnvironment.Name);
Assert.NotNull(env2.Endpoints[AzureEnvironment.Endpoint.ServiceManagement]);
AzureEnvironment newEnv = new AzureEnvironment
{
Name = azureEnvironment.Name
};
newEnv.Endpoints[AzureEnvironment.Endpoint.Graph] = "foo";
env2 = client.AddOrSetEnvironment(newEnv);
Assert.Equal("foo", env2.Endpoints[AzureEnvironment.Endpoint.Graph]);
Assert.NotNull(env2.Endpoints[AzureEnvironment.Endpoint.ServiceManagement]);
}
