public void SelectNonExistentContext()
{
var cmdlet = new SelectAzureRmContext();
var profile = CreateMultipleContextProfile();
var defaultContext = profile.DefaultContext;
var defaultContextName = profile.DefaultContextKey;
cmdlet.CommandRuntime = commandRuntimeMock;
cmdlet.DefaultProfile = profile;
cmdlet.MyInvocation.BoundParameters.Add("Name", "This context does not exist");
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
Assert.NotNull(commandRuntimeMock.OutputPipeline);
Assert.Single(commandRuntimeMock.OutputPipeline);
PSAzureContext testContext = commandRuntimeMock.OutputPipeline[0] as PSAzureContext;
Assert.NotNull(testContext);
Assert.NotNull(testContext.Name);
Assert.True(defaultContext.IsEqual(testContext));
Assert.True(profile.Contexts.ContainsKey(defaultContextName));
Assert.True(defaultContext.IsEqual(profile.DefaultContext));
Assert.False(string.IsNullOrEmpty(profile.DefaultContextKey));
Assert.Equal(defaultContextName, profile.DefaultContextKey);
}
public void RenameDefaultContext()
{
var cmdlet = new RenameAzureRmContext();
var profile = CreateMultipleContextProfile();
var defaultContext = profile.DefaultContext;
var newContextName = "New Context Name";
var contextCount = profile.Contexts.Count;
cmdlet.CommandRuntime = commandRuntimeMock;
cmdlet.DefaultProfile = profile;
cmdlet.MyInvocation.BoundParameters.Add("SourceName", profile.DefaultContextKey);
cmdlet.MyInvocation.BoundParameters.Add("TargetName", newContextName);
cmdlet.PassThru = true;
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
Assert.NotNull(commandRuntimeMock.OutputPipeline);
Assert.Single(commandRuntimeMock.OutputPipeline);
PSAzureContext testContext = commandRuntimeMock.OutputPipeline[0] as PSAzureContext;
Assert.NotNull(testContext);
Assert.NotNull(testContext.Name);
Assert.True(defaultContext.IsEqual(testContext));
Assert.True(profile.Contexts.ContainsKey(newContextName));
Assert.True(defaultContext.IsEqual(profile.DefaultContext));
Assert.False(string.IsNullOrEmpty(profile.DefaultContextKey));
Assert.Equal(newContextName, profile.DefaultContextKey);
Assert.Equal(contextCount, profile.Contexts.Count);
}
public void RemoveNonDefaultContext()
{
var cmdlet = new RemoveAzureRmContext();
var profile = CreateMultipleContextProfile();
var removedContextKey = profile.Contexts.Keys.First(k => !string.Equals(k, profile.DefaultContextKey));
var removedContext = profile.Contexts[removedContextKey];
var defaultContextKey = profile.DefaultContextKey;
cmdlet.CommandRuntime = commandRuntimeMock;
cmdlet.DefaultProfile = profile;
cmdlet.PassThru = true;
cmdlet.MyInvocation.BoundParameters.Add("Name", removedContextKey);
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
Assert.True(commandRuntimeMock.OutputPipeline != null && commandRuntimeMock.OutputPipeline.Count == 1);
PSAzureContext testContext = commandRuntimeMock.OutputPipeline[0] as PSAzureContext;
Assert.NotNull(testContext);
Assert.NotNull(testContext.Name);
Assert.True(removedContext.IsEqual(testContext));
Assert.False(profile.Contexts.ContainsKey(removedContextKey));
Assert.DoesNotContain(profile.Contexts, c => removedContext.IsEqual(c.Value));
Assert.Equal(defaultContextKey, profile.DefaultContextKey);
}
public void CanConvertProfieWithCustomEnvironment()
{
IAzureContext context = new AzureContext(new AzureSubscription(), new AzureAccount(), new AzureEnvironment(), new AzureTenant(), new byte[0]);
var testContext = new PSAzureContext(context);
var testEnvironment = new PSAzureEnvironment(AzureEnvironment.PublicEnvironments["AzureCloud"]);
testEnvironment.Name = "ExtraEnvironment";
var testProfile = new PSAzureProfile();
testProfile.Context = testContext;
testProfile.Environments.Add("ExtraEnvironment", testEnvironment);
ConvertAndTestProfile(testProfile, (profile) =>
{
Assert.NotEmpty(profile.EnvironmentTable);
Assert.True(profile.EnvironmentTable.ContainsKey("ExtraEnvironment"));
Assert.NotEmpty(profile.Contexts);
Assert.NotNull(profile.DefaultContext);
Assert.NotEmpty(profile.DefaultContextKey);
Assert.Equal("Default", profile.DefaultContextKey);
Assert.Collection(profile.Environments.OrderBy(e => e.Name),
(e) => Assert.Equal(e, AzureEnvironment.PublicEnvironments[EnvironmentName.AzureChinaCloud]),
(e) => Assert.Equal(e, AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud]),
(e) => Assert.Equal(e, AzureEnvironment.PublicEnvironments[EnvironmentName.AzureGermanCloud]),
(e) => Assert.Equal(e, AzureEnvironment.PublicEnvironments[EnvironmentName.AzureUSGovernment]),
(e) => Assert.Equal(e, testEnvironment));
});
}
public void SelectNonDefaultContext()
{
var cmdlet = new SelectAzureRmContext();
var profile = CreateMultipleContextProfile();
var selectedContextName = profile.Contexts.Keys.First(k => !string.Equals(k, profile.DefaultContextKey));
var selectedContext = profile.Contexts[selectedContextName];
Assert.NotNull(selectedContext);
cmdlet.CommandRuntime = commandRuntimeMock;
cmdlet.DefaultProfile = profile;
cmdlet.MyInvocation.BoundParameters.Add("Name", selectedContextName);
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
Assert.NotNull(commandRuntimeMock.OutputPipeline);
Assert.Equal(1, commandRuntimeMock.OutputPipeline.Count);
PSAzureContext testContext = commandRuntimeMock.OutputPipeline[0] as PSAzureContext;
Assert.NotNull(testContext);
Assert.NotNull(testContext.Name);
Assert.True(selectedContext.IsEqual(testContext));
Assert.True(profile.Contexts.ContainsKey(selectedContextName));
Assert.True(selectedContext.IsEqual(profile.DefaultContext));
Assert.False(string.IsNullOrEmpty(profile.DefaultContextKey));
Assert.Equal(selectedContextName, profile.DefaultContextKey);
}
public void RemoveDefaultContext()
{
var cmdlet = new RemoveAzureRmContext();
var profile = CreateMultipleContextProfile();
var defaultContext = profile.DefaultContext;
var defaultContextName = profile.DefaultContextKey;
cmdlet.CommandRuntime = commandRuntimeMock;
cmdlet.DefaultProfile = profile;
cmdlet.Force = true;
cmdlet.PassThru = true;
cmdlet.MyInvocation.BoundParameters.Add("Name", profile.DefaultContextKey);
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
Assert.True(commandRuntimeMock.OutputPipeline != null && commandRuntimeMock.OutputPipeline.Count == 1);
PSAzureContext testContext = commandRuntimeMock.OutputPipeline[0] as PSAzureContext;
Assert.NotNull(testContext);
Assert.NotNull(testContext.Name);
Assert.True(defaultContext.IsEqual(testContext));
Assert.False(profile.Contexts.ContainsKey(defaultContextName));
Assert.False(profile.Contexts.Any(c => defaultContext.IsEqual(c.Value)));
Assert.False(string.IsNullOrEmpty(profile.DefaultContextKey));
Assert.NotNull(profile.DefaultContext);
}
public static AzureRmProfile CreateAzureRMProfile(string storageAccount)
{
var tenantId = Guid.NewGuid();
var subscriptionId = Guid.NewGuid();
var domain = "Contoso.com";
var context = new PSAzureContext()
{
Account = new PSAzureRmAccount
{
Id = "*****@*****.**",
Type = "User"
},
Environment = (PSAzureEnvironment)AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud],
Subscription =
new PSAzureSubscription
{
CurrentStorageAccount = storageAccount,
Id = subscriptionId.ToString(),
Name = "Test Subscription 1",
TenantId = tenantId.ToString()
},
Tenant = new PSAzureTenant
{
Directory = domain,
Id = tenantId.ToString()
}
};
return(new AzureRmProfile()
{
DefaultContext = context
});
}
public override void ExecuteCmdlet()
{
string name = null;
if (ParameterSetName == InputObjectParameterSet)
{
name = InputObject?.Name;
}
else if (MyInvocation.BoundParameters.ContainsKey("Name"))
{
name = MyInvocation.BoundParameters["Name"] as string;
}
if (!string.IsNullOrWhiteSpace(name))
{
var defaultProfile = DefaultProfile as AzureRmProfile;
ConfirmAction(Force.IsPresent,
string.Format(Resources.RemoveDefaultContextQuery, name),
string.Format(Resources.RemoveContextMessage, name),
Resources.RemoveContextTarget,
() =>
{
ModifyContext((profile, client) =>
{
if (profile.Contexts.ContainsKey(name))
{
var removedContext = profile.Contexts[name];
if (client.TryRemoveContext(name))
{
if (removedContext.Account.Type == AzureAccount.AccountType.User &&
!profile.Contexts.Any(c => c.Value.Account.Id == removedContext.Account.Id))
{
PowerShellTokenCacheProvider tokenCacheProvider;
if (!AzureSession.Instance.TryGetComponent(PowerShellTokenCacheProvider.PowerShellTokenCacheProviderKey, out tokenCacheProvider))
{
WriteWarning(string.Format(Resources.ClientFactoryNotRegisteredRemoval, removedContext.Account.Id));
}
else
{
if (!tokenCacheProvider.TryRemoveAccount(removedContext.Account.Id))
{
WriteWarning(string.Format(Resources.NoContextsRemain, removedContext.Account.Id));
}
}
}
if (this.PassThru.IsPresent)
{
var outContext = new PSAzureContext(removedContext);
outContext.Name = name;
WriteObject(outContext);
}
}
}
});
},
() => string.Equals(defaultProfile.DefaultContextKey, name, StringComparison.OrdinalIgnoreCase));
}
}
void WriteContext(IAzureContext azureContext, string name)
{
var context = new PSAzureContext(azureContext);
if (name != null)
{
context.Name = name;
}
WriteObject(context);
}
public override void ExecuteCmdlet()
{
string sourceName = null;
if (ParameterSetName == InputObjectParameterSet)
{
sourceName = InputObject?.Name;
}
else if (MyInvocation.BoundParameters.ContainsKey(SourceParameterName))
{
sourceName = MyInvocation.BoundParameters[SourceParameterName] as string;
}
if (!string.IsNullOrWhiteSpace(sourceName) && MyInvocation.BoundParameters.ContainsKey(TargetParameterName))
{
var targetName = MyInvocation.BoundParameters[TargetParameterName] as string;
var defaultProfile = DefaultProfile as AzureRmProfile;
if (!string.IsNullOrWhiteSpace(sourceName) && !string.IsNullOrWhiteSpace(targetName) && defaultProfile != null && !string.Equals(sourceName, targetName, StringComparison.OrdinalIgnoreCase))
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.OverwriteContextWarning, targetName, sourceName),
string.Format(Resources.RenameContextMessage, sourceName, targetName),
"Context",
() =>
{
ModifyContext((profile, client) =>
{
var defaultContextName = profile.DefaultContextKey;
if (profile.Contexts.ContainsKey(sourceName) && (!profile.Contexts.ContainsKey(targetName) || client.TryRemoveContext(targetName)))
{
if (client.TryRenameContext(sourceName, targetName) &&
(!string.Equals(targetName, defaultContextName, StringComparison.OrdinalIgnoreCase) ||
client.TrySetDefaultContext(targetName)) &&
PassThru.IsPresent)
{
var outContext = new PSAzureContext(profile.Contexts[targetName]);
outContext.Name = targetName;
WriteObject(outContext);
}
}
});
},
() => defaultProfile.Contexts.ContainsKey(targetName));
}
}
}
public void CanConvertValidPSAzureContexts(string account, string subscription, string storageAccount, string storageAccountName)
{
var tenantId = Guid.NewGuid();
var subscriptionId = Guid.NewGuid();
var domain = GetDomainName(account);
var oldContext = new PSAzureContext()
{
Account = new PSAzureRmAccount
{
Id = account,
AccountType = "User"
},
Environment = (PSAzureEnvironment)AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud],
Subscription =
new PSAzureSubscription
{
CurrentStorageAccount = storageAccount,
CurrentStorageAccountName = storageAccountName,
SubscriptionId = subscriptionId.ToString(),
SubscriptionName = subscription,
TenantId = tenantId.ToString()
},
Tenant = new PSAzureTenant
{
Domain = domain,
TenantId = tenantId.ToString()
}
};
var context = (AzureContext)oldContext;
Assert.NotNull(context);
Assert.NotNull(context.Account);
Assert.Equal(oldContext.Account.AccountType, context.Account.Type.ToString());
Assert.Equal(oldContext.Account.Id, context.Account.Id);
Assert.NotNull(context.Tenant);
Assert.Equal(oldContext.Tenant.Domain, context.Tenant.Domain);
Assert.Equal(oldContext.Tenant.TenantId, context.Tenant.Id.ToString());
Assert.NotNull(context.Subscription);
Assert.Equal(oldContext.Subscription.SubscriptionName, context.Subscription.Name);
Assert.Equal(oldContext.Subscription.SubscriptionId, context.Subscription.Id.ToString());
Assert.True(context.Subscription.IsPropertySet(AzureSubscription.Property.Tenants));
Assert.Equal(oldContext.Subscription.TenantId, context.Subscription.GetProperty(AzureSubscription.Property.Tenants));
Assert.True(context.Subscription.IsPropertySet(AzureSubscription.Property.StorageAccount));
Assert.Equal(storageAccount, context.Subscription.GetProperty(AzureSubscription.Property.StorageAccount));
}
void WriteContext(IAzureContext azureContext, string name)
{
var context = new PSAzureContext(azureContext);
if (name != null)
{
context.Name = name;
}
// Don't write the default (empty) context to the output stream
if (context.Account == null &&
context.Environment == null &&
context.Subscription == null &&
context.Tenant == null)
{
return;
}
WriteObject(context);
}
private void CompleteContextProcessing(IProfileOperations profile)
{
var context = profile.DefaultContext;
if (context != null &&
context.Subscription != null &&
context.Subscription.State != null &&
!context.Subscription.State.Equals(
"Enabled",
StringComparison.OrdinalIgnoreCase))
{
WriteWarning(string.Format(
Resources.SelectedSubscriptionNotActive,
context.Subscription.State));
}
if (context != null)
{
if (MyInvocation.BoundParameters.ContainsKey(nameof(ExtendedProperty)))
{
foreach (var property in ExtendedProperty)
{
if (ShouldProcess(string.Format(Resources.ContextNameTarget, Name ?? "default"),
string.Format(Resources.SetPropertyAction, property.Key, property.Value)))
{
context.SetProperty(property.Key, property.Value);
}
}
}
var psContext = new PSAzureContext(context);
string name = Name;
if (string.IsNullOrWhiteSpace(name))
{
profile.TryFindContext(context, out name);
}
psContext.Name = name;
WriteObject(psContext);
}
}
public override void ExecuteCmdlet()
{
string name = null;
if (ParameterSetName == InputObjectParameterSet)
{
name = InputObject?.Name;
}
else if (MyInvocation.BoundParameters.ContainsKey("Name"))
{
name = MyInvocation.BoundParameters["Name"] as string;
}
if (!string.IsNullOrWhiteSpace(name))
{
var defaultProfile = DefaultProfile as AzureRmProfile;
ConfirmAction(Force.IsPresent,
string.Format(Resources.RemoveDefaultContextQuery, name),
string.Format(Resources.RemoveContextMessage, name),
Resources.RemoveContextTarget,
() =>
{
ModifyContext((profile, client) =>
{
if (profile.Contexts.ContainsKey(name))
{
var removedContext = profile.Contexts[name];
if (client.TryRemoveContext(name) && PassThru.IsPresent)
{
var outContext = new PSAzureContext(removedContext);
outContext.Name = name;
WriteObject(outContext);
}
}
});
},
() => string.Equals(defaultProfile.DefaultContextKey, name, StringComparison.OrdinalIgnoreCase));
}
}
public void ListMultipleContexts()
{
var cmdlet = new GetAzureRMContextCommand();
var profile = CreateMultipleContextProfile();
cmdlet.CommandRuntime = commandRuntimeMock;
cmdlet.DefaultProfile = profile;
cmdlet.ListAvailable = true;
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
Assert.True(commandRuntimeMock.OutputPipeline != null && commandRuntimeMock.OutputPipeline.Count == profile.Contexts.Count);
foreach (var output in commandRuntimeMock.OutputPipeline)
{
PSAzureContext testContext = output as PSAzureContext;
Assert.NotNull(testContext);
Assert.NotNull(testContext.Name);
Assert.True(profile.Contexts.ContainsKey(testContext.Name));
var validateContext = profile.Contexts[testContext.Name];
Assert.NotNull(validateContext);
Assert.True(validateContext.IsEqual(testContext));
profile.TryRemoveContext(testContext.Name);
}
}
