public void RestartsWebsiteSlot()
{
// Setup
const string websiteName = "website1";
const string slot = "staging";
Mock <IWebsitesClient> websitesClientMock = new Mock <IWebsitesClient>();
websitesClientMock.Setup(f => f.RestartWebsite(websiteName, slot));
// Test
RestartAzureWebsiteCommand restartAzureWebsiteCommand = new RestartAzureWebsiteCommand()
{
CommandRuntime = new MockCommandRuntime(),
Name = websiteName,
WebsitesClient = websitesClientMock.Object,
Slot = slot
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = base.subscriptionId
};
subscription.SetDefault();
currentProfile.SubscriptionTable[new Guid(base.subscriptionId)] = subscription;
restartAzureWebsiteCommand.ExecuteCmdlet();
websitesClientMock.Verify(f => f.RestartWebsite(websiteName, slot), Times.Once());
}
public void DisableAzureWebsiteApplicationDiagnosticApplicationTableLog()
{
// Setup
websitesClientMock.Setup(f => f.DisableApplicationDiagnostic(
websiteName,
WebsiteDiagnosticOutput.StorageTable, null));
disableAzureWebsiteApplicationDiagnosticCommand = new DisableAzureWebsiteApplicationDiagnosticCommand()
{
CommandRuntime = commandRuntimeMock.Object,
Name = websiteName,
WebsitesClient = websitesClientMock.Object,
TableStorage = true
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = base.subscriptionId
};
subscription.SetDefault();
currentProfile.SubscriptionTable[new Guid(base.subscriptionId)] = subscription;
// Test
disableAzureWebsiteApplicationDiagnosticCommand.ExecuteCmdlet();
// Assert
websitesClientMock.Verify(f => f.DisableApplicationDiagnostic(
websiteName,
WebsiteDiagnosticOutput.StorageTable, null), Times.Once());
commandRuntimeMock.Verify(f => f.WriteObject(true), Times.Never());
}
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;
}
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";
var profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
AzureSMCmdlet.CurrentProfile = profile;
ProfileClient client = new ProfileClient(profile);
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(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
Assert.False(client.Profile.Environments.ContainsKey(name));
}
public void SaveAzureWebsiteLogWithNoFileExtensionTest()
{
TestExecutionHelpers.RetryAction(
() =>
{
// Setup
string expectedOutput = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "file_without_ext.zip");
SimpleDeploymentServiceManagement deploymentChannel = new SimpleDeploymentServiceManagement
{
DownloadLogsThunk = ar => new MemoryStream(Encoding.UTF8.GetBytes("test with no extension"))
};
// Test
SaveAzureWebsiteLogCommand getAzureWebsiteLogCommand = new SaveAzureWebsiteLogCommand(deploymentChannel)
{
Name = "website1",
ShareChannel = true,
WebsitesClient = clientMock.Object,
CommandRuntime = new MockCommandRuntime(),
Output = "file_without_ext"
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = new Guid(base.subscriptionId)
};
subscription.Properties[AzureSubscription.Property.Default] = "True";
currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription;
getAzureWebsiteLogCommand.DefaultCurrentPath = AppDomain.CurrentDomain.BaseDirectory;
getAzureWebsiteLogCommand.ExecuteCmdlet();
Assert.Equal("test with no extension", FileUtilities.DataStore.ReadFileAsText(expectedOutput));
});
}
public void IgnoresAddingDuplicatedEnvironment()
{
var profile = new AzureSMProfile();
var commandRuntimeMock = new Mock <ICommandRuntime>();
SetupConfirmation(commandRuntimeMock);
var cmdlet = new AddAzureRMEnvironmentCommand()
{
CommandRuntime = commandRuntimeMock.Object,
Name = "Katal",
PublishSettingsFileUrl = "http://microsoft.com",
ServiceEndpoint = "endpoint.net",
ManagementPortalUrl = "management portal url",
StorageEndpoint = "endpoint.net"
};
cmdlet.InvokeBeginProcessing();
cmdlet.ExecuteCmdlet();
cmdlet.InvokeEndProcessing();
ProfileClient client = new ProfileClient(profile);
int count = client.Profile.Environments.Count;
// Add again
cmdlet.Name = "kAtAl";
cmdlet.ExecuteCmdlet();
AzureEnvironment env = AzureRmProfileProvider.Instance.Profile.Environments["KaTaL"];
Assert.Equal(env.Name, cmdlet.Name);
}
/// <summary>
/// Creates new MediaServicesClient.
/// </summary>
/// <param name="subscription">The Microsoft Azure subscription data object</param>
/// <param name="logger">The logger action</param>
public MediaServicesClient(AzureSMProfile profile, AzureSubscription subscription, Action <string> logger)
: this(
logger,
AzureSession.ClientFactory.CreateClient <MediaServicesManagementClient>(profile, subscription, AzureEnvironment.Endpoint.ServiceManagement),
AzureSession.ClientFactory.CreateClient <StorageManagementClient>(profile, subscription, AzureEnvironment.Endpoint.ServiceManagement))
{
}
public EnvironmentSetupHelper()
{
AzureSessionInitializer.InitializeAzureSession();
var datastore = new MemoryDataStore();
AzureSession.Instance.DataStore = datastore;
var profile = new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
AzureSMCmdlet.CurrentProfile = profile;
AzureSession.Instance.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;
}
}
public static IHDInsightSubscriptionCredentials GetSubscriptionCredentials(
this IAzureHDInsightCommonCommandBase command,
AzureSubscription currentSubscription,
AzureEnvironment environment,
AzureSMProfile profile)
{
var accountId = currentSubscription.Account;
Debug.Assert(profile.Accounts.ContainsKey(accountId));
if (profile.Accounts[accountId].Type == AzureAccount.AccountType.Certificate)
{
return(GetSubscriptionCertificateCredentials(command, currentSubscription, profile.Accounts[accountId], environment));
}
else if (profile.Accounts[accountId].Type == AzureAccount.AccountType.User)
{
return(GetAccessTokenCredentials(command, currentSubscription, profile.Accounts[accountId], environment));
}
else if (profile.Accounts[accountId].Type == AzureAccount.AccountType.ServicePrincipal)
{
return(GetAccessTokenCredentials(command, currentSubscription, profile.Accounts[accountId], environment));
}
throw new NotSupportedException();
}
public void AddsEnvironmentWithMinimumInformation()
{
var profile = new AzureSMProfile();
Mock <ICommandRuntime> commandRuntimeMock = new Mock <ICommandRuntime>();
AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand()
{
CommandRuntime = commandRuntimeMock.Object,
Name = "Katal",
PublishSettingsFileUrl = "http://microsoft.com",
EnableAdfsAuthentication = true,
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.Profile.Environments["KaTaL"];
Assert.Equal(env.Name, cmdlet.Name);
Assert.True(env.OnPremise);
Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], cmdlet.PublishSettingsFileUrl);
}
public EnvironmentSetupHelper()
{
TestExecutionHelpers.SetUpSessionAndProfile();
var datastore = new MemoryDataStore();
AzureSession.Instance.DataStore = datastore;
var rmprofile = new AzureRmProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
rmprofile.EnvironmentTable.Add("foo", new AzureEnvironment(AzureEnvironment.PublicEnvironments.Values.FirstOrDefault()));
rmprofile.DefaultContext = new AzureContext(new AzureSubscription(), new AzureAccount(), rmprofile.EnvironmentTable["foo"], new AzureTenant());
rmprofile.DefaultContext.Subscription.SetEnvironment("foo");
if (AzureRmProfileProvider.Instance.Profile == null)
{
AzureRmProfileProvider.Instance.Profile = rmprofile;
}
AzureSession.Instance.DataStore = datastore;
// Ignore SSL errors
System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true;
#if !NETSTANDARD
ServiceManagementProfileProvider.InitializeServiceManagementProfile();
var profile = new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
ProfileClient = new ProfileClient(profile);
AdalTokenCache.ClearCookies();
#endif
// Set RunningMocked
TestMockSupport.RunningMocked = HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback;
if (File.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".azure", "testcredentials.json")))
{
SetEnvironmentVariableFromCredentialFile();
}
}
public void AddsAzureEnvironment()
{
var profile = new AzureSMProfile();
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 AddsEnvironmentWithStorageEndpoint()
{
var profile = new AzureSMProfile();
Mock <ICommandRuntime> commandRuntimeMock = new Mock <ICommandRuntime>();
PSAzureEnvironment actual = null;
commandRuntimeMock.Setup(f => f.WriteObject(It.IsAny <object>()))
.Callback((object output) => actual = (PSAzureEnvironment)output);
AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand()
{
CommandRuntime = commandRuntimeMock.Object,
Name = "Katal",
PublishSettingsFileUrl = "http://microsoft.com",
StorageEndpoint = "core.windows.net",
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.Profile.Environments["KaTaL"];
Assert.Equal(env.Name, cmdlet.Name);
Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], actual.PublishSettingsFileUrl);
}
public void BaseSetup()
{
AzureSessionInitializer.InitializeAzureSession();
ServiceManagementProfileProvider.InitializeServiceManagementProfile();
if (AzureSession.Instance.DataStore == null || (AzureSession.Instance.DataStore != null && !(AzureSession.Instance.DataStore is MemoryDataStore)))
{
AzureSession.Instance.DataStore = new MemoryDataStore();
}
currentProfile = new AzureSMProfile();
if (currentProfile.Context.Subscription == null)
{
var newGuid = Guid.NewGuid();
var client = new ProfileClient(currentProfile);
var account = new AzureAccount
{
Id = "test",
Type = AzureAccount.AccountType.User,
};
account.SetSubscriptions(newGuid.ToString());
client.AddOrSetAccount(account);
var sub = new AzureSubscription {
Id = newGuid.ToString(), Name = "test"
};
sub.SetEnvironment(EnvironmentName.AzureCloud);
sub.SetAccount("test");
client.AddOrSetSubscription(sub);
client.SetSubscriptionAsDefault(newGuid, "test");
}
AzureSession.Instance.AuthenticationFactory = new MockTokenAuthenticationFactory();
}
public TClient CreateClient <TClient>(AzureSMProfile profile, AzureSubscription subscription, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient>
{
if (subscription == null)
{
throw new ArgumentException(Microsoft.Azure.Commands.ResourceManager.Common.Properties.Resources.InvalidDefaultSubscription);
}
if (profile == null)
{
profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription.Id.ToString(), "fake_token");
if (HttpMockServer.GetCurrentMode() != HttpRecorderMode.Playback)
{
ProfileClient profileClient = new ProfileClient(profile);
AzureContext context = new AzureContext(
subscription,
profileClient.GetAccount(subscription.Account),
profileClient.GetEnvironmentOrDefault(subscription.Environment)
);
creds = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
}
Uri endpointUri = profile.Environments[subscription.Environment].GetEndpointAsUri(endpoint);
return(CreateCustomClient <TClient>(creds, endpointUri));
}
public static IJobSubmissionClientCredential GetJobSubmissionClientCredentials(
this IAzureHDInsightJobCommandCredentialsBase command,
AzureSubscription currentSubscription,
AzureEnvironment environment, string cluster,
AzureSMProfile profile)
{
IJobSubmissionClientCredential clientCredential = null;
if (command.Credential != null)
{
clientCredential = new BasicAuthCredential
{
Server = GatewayUriResolver.GetGatewayUri(cluster),
UserName = command.Credential.UserName,
Password = command.Credential.GetCleartextPassword()
};
}
else if (currentSubscription.IsNotNull())
{
var subscriptionCredentials = GetSubscriptionCredentials(command, currentSubscription, environment, profile);
var asCertificateCredentials = subscriptionCredentials as HDInsightCertificateCredential;
var asTokenCredentials = subscriptionCredentials as HDInsightAccessTokenCredential;
if (asCertificateCredentials.IsNotNull())
{
clientCredential = new JobSubmissionCertificateCredential(asCertificateCredentials, cluster);
}
else if (asTokenCredentials.IsNotNull())
{
clientCredential = new JobSubmissionAccessTokenCredential(asTokenCredentials, cluster);
}
}
return(clientCredential);
}
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 GetsCorrectContext()
{
AzureSMProfile profile = new AzureSMProfile();
string accountId = "accountId";
Guid subscriptionId = Guid.NewGuid();
profile.AccountTable.Add(accountId, new AzureAccount {
Id = accountId, Type = AzureAccount.AccountType.User
});
var sub = new AzureSubscription
{
Name = "hello",
Id = subscriptionId.ToString()
};
sub.SetAccount(accountId);
sub.SetEnvironment(EnvironmentName.AzureChinaCloud);
profile.SubscriptionTable.Add(subscriptionId, sub);
profile.DefaultSubscription = profile.SubscriptionTable[subscriptionId];
IAzureContext context = profile.Context;
Assert.Equal(accountId, context.Account.Id);
Assert.Equal(subscriptionId.ToString(), context.Subscription.Id);
Assert.Equal(EnvironmentName.AzureChinaCloud, context.Environment.Name);
}
public void CanGetBasicAuthCredentialFromCredentials()
{
var getClustersCommand = new GetAzureHDInsightJobCommand();
getClustersCommand.Credential = GetPSCredential(TestCredentials.AzureUserName, TestCredentials.AzurePassword);
var waSubscription = new AzureSubscription()
{
Id = IntegrationTestBase.TestCredentials.SubscriptionId,
};
waSubscription.Account = "test";
var profile = new AzureSMProfile();
ProfileClient profileClient = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)));
var accessTokenCreds = getClustersCommand.GetJobSubmissionClientCredentials(
waSubscription,
profileClient.Profile.Context.Environment,
IntegrationTestBase.TestCredentials.WellKnownCluster.DnsName, profile);
Assert.IsInstanceOfType(accessTokenCreds, typeof(BasicAuthCredential));
var asBasicAuthCredentials = accessTokenCreds as BasicAuthCredential;
Assert.IsNotNull(asBasicAuthCredentials);
Assert.AreEqual(IntegrationTestBase.TestCredentials.AzureUserName, asBasicAuthCredentials.UserName);
Assert.AreEqual(IntegrationTestBase.TestCredentials.AzurePassword, asBasicAuthCredentials.Password);
}
public void ProcessRestartWebsiteTest()
{
// Setup
const string websiteName = "website1";
Mock <IWebsitesClient> websitesClientMock = new Mock <IWebsitesClient>();
websitesClientMock.Setup(f => f.RestartWebsite(websiteName, null));
// Test
RestartAzureWebsiteCommand restartAzureWebsiteCommand = new RestartAzureWebsiteCommand()
{
CommandRuntime = new MockCommandRuntime(),
Name = websiteName,
WebsitesClient = websitesClientMock.Object
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = new Guid(base.subscriptionId)
};
subscription.Properties[AzureSubscription.Property.Default] = "True";
currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription;
restartAzureWebsiteCommand.ExecuteCmdlet();
websitesClientMock.Verify(f => f.RestartWebsite(websiteName, null), Times.Once());
}
public void AccountMatchingIgnoresCase()
{
var profile = new AzureSMProfile();
string accountName = "*****@*****.**";
string accountNameCase = "*****@*****.**";
var subscriptionId = Guid.NewGuid();
var tenantId = Guid.NewGuid();
var account = new AzureAccount
{
Id = accountName,
Type = AzureAccount.AccountType.User
};
account.SetProperty(AzureAccount.Property.Subscriptions, subscriptionId.ToString());
account.SetProperty(AzureAccount.Property.Tenants, tenantId.ToString());
var subscription = new AzureSubscription
{
Id = subscriptionId,
Account = accountNameCase,
Environment = EnvironmentName.AzureCloud
};
subscription.SetProperty(AzureSubscription.Property.Default, "true");
subscription.SetProperty(AzureSubscription.Property.Tenants, tenantId.ToString());
profile.Accounts.Add(accountName, account);
profile.Subscriptions.Add(subscriptionId, subscription);
Assert.NotNull(profile.Context);
Assert.NotNull(profile.Context.Account);
Assert.NotNull(profile.Context.Environment);
Assert.NotNull(profile.Context.Subscription);
Assert.Equal(account, profile.Context.Account);
Assert.Equal(subscription, profile.Context.Subscription);
}
public void StartsWebsiteSlot()
{
const string slot = "staging";
const string websiteName = "website1";
// Setup
Mock <IWebsitesClient> websitesClientMock = new Mock <IWebsitesClient>();
websitesClientMock.Setup(f => f.StartWebsite(websiteName, slot));
// Test
StartAzureWebsiteCommand startAzureWebsiteCommand = new StartAzureWebsiteCommand()
{
CommandRuntime = new MockCommandRuntime(),
Name = websiteName,
WebsitesClient = websitesClientMock.Object,
Slot = slot
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = new Guid(base.subscriptionId)
};
subscription.Properties[AzureSubscription.Property.Default] = "True";
currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription;
startAzureWebsiteCommand.ExecuteCmdlet();
websitesClientMock.Verify(f => f.StartWebsite(websiteName, slot), Times.Once());
}
/// <summary>
/// Creates the client.
/// </summary>
/// <typeparam name="TClient">The type of the client.</typeparam>
/// <param name="profile">The profile.</param>
/// <param name="subscription">The subscription.</param>
/// <param name="endpoint">The endpoint.</param>
/// <returns></returns>
/// <exception cref="System.ApplicationException"></exception>
/// <exception cref="System.ArgumentException">
/// accountName
/// or
/// environment
/// </exception>
public virtual TClient CreateClient <TClient>(AzureSMProfile profile, AzureSubscription subscription, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient>
{
if (subscription == null)
{
throw new ApplicationException(Resources.InvalidDefaultSubscription);
}
if (!profile.Accounts.ContainsKey(subscription.Account))
{
throw new ArgumentException(string.Format("Account with name '{0}' does not exist.", subscription.Account), "accountName");
}
if (!profile.Environments.ContainsKey(subscription.Environment))
{
throw new ArgumentException(string.Format(Resources.EnvironmentNotFound, subscription.Environment));
}
AzureContext context = new AzureContext(subscription,
profile.Accounts[subscription.Account],
profile.Environments[subscription.Environment]);
TClient client = CreateClient <TClient>(context, endpoint);
foreach (IClientAction action in GetActions())
{
action.Apply <TClient>(client, profile, endpoint);
}
return(client);
}
public override void ExecuteCmdlet()
{
AzureSMProfile AzureSMProfile;
AzureProfileSettings settings;
if (ParameterSetName == PropertyBagParameterSet)
{
AzureSMProfile = new AzureSMProfile();
var actualParameterSet = ParseHashTableParameters(Properties, out settings);
InitializeAzureProfile(AzureSMProfile, actualParameterSet, settings);
}
else if (ParameterSetName == FileParameterSet)
{
if (string.IsNullOrEmpty(Path) || !File.Exists(Path))
{
throw new ArgumentException(Resources.InvalidNewProfilePath);
}
AzureSMProfile = new AzureSMProfile(Path);
}
else
{
AzureSMProfile = new AzureSMProfile();
settings = AzureProfileSettings.Create(this);
InitializeAzureProfile(AzureSMProfile, ParameterSetName, settings);
}
WriteObject(AzureSMProfile);
}
public void SaveAzureWebsiteLogTest()
{
// Setup
SimpleDeploymentServiceManagement deploymentChannel = new SimpleDeploymentServiceManagement
{
DownloadLogsThunk = ar => new MemoryStream(Encoding.UTF8.GetBytes("test"))
};
// Test
SaveAzureWebsiteLogCommand getAzureWebsiteLogCommand = new SaveAzureWebsiteLogCommand(deploymentChannel)
{
Name = "website1",
ShareChannel = true,
WebsitesClient = clientMock.Object,
CommandRuntime = new MockCommandRuntime(),
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = new Guid(base.subscriptionId)
};
subscription.Properties[AzureSubscription.Property.Default] = "True";
currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription;
getAzureWebsiteLogCommand.DefaultCurrentPath = AppDomain.CurrentDomain.BaseDirectory;
getAzureWebsiteLogCommand.ExecuteCmdlet();
Assert.Equal("test", FileUtilities.DataStore.ReadFileAsText(
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, SaveAzureWebsiteLogCommand.DefaultOutput)));
}
public void ProcessShowWebsiteTest()
{
// Setup
var mockClient = new Mock <IWebsitesClient>();
mockClient.Setup(c => c.GetWebsite("website1", null))
.Returns(new Site
{
Name = "website1",
WebSpace = "webspace1",
HostNames = new[] { "website1.cloudapp.com" }
});
// Test
ShowAzureWebsiteCommand showAzureWebsiteCommand = new ShowAzureWebsiteCommand
{
CommandRuntime = new MockCommandRuntime(),
Name = "website1",
WebsitesClient = mockClient.Object
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = base.subscriptionId
};
subscription.SetDefault();
currentProfile.SubscriptionTable[new Guid(base.subscriptionId)] = subscription;
// Show existing website
showAzureWebsiteCommand.ExecuteCmdlet();
}
public static IAzureContextContainer CreateAzureSMProfile(string storageAccount)
{
#if !NETSTANDARD
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.ToString(),
Name = "Test Subscription 1",
};
subscription.SetEnvironment(EnvironmentName.AzureCloud);
subscription.SetAccount(account.Id);
subscription.SetTenant(tenantId.ToString());
subscription.SetStorageAccount(storageAccount);
client.AddOrSetAccount(account);
client.AddOrSetSubscription(subscription);
client.SetSubscriptionAsDefault(subscriptionId, account.Id);
return(profile);
#else
return(null);
#endif
}
public void DisableAzureWebsiteApplicationDiagnosticApplication()
{
// Setup
websitesClientMock.Setup(f => f.DisableApplicationDiagnostic(
websiteName,
WebsiteDiagnosticOutput.FileSystem, null));
disableAzureWebsiteApplicationDiagnosticCommand = new DisableAzureWebsiteApplicationDiagnosticCommand()
{
CommandRuntime = commandRuntimeMock.Object,
Name = websiteName,
WebsitesClient = websitesClientMock.Object,
File = true,
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = new Guid(base.subscriptionId)
};
subscription.Properties[AzureSubscription.Property.Default] = "True";
currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription;
// Test
disableAzureWebsiteApplicationDiagnosticCommand.ExecuteCmdlet();
// Assert
websitesClientMock.Verify(f => f.DisableApplicationDiagnostic(
websiteName,
WebsiteDiagnosticOutput.FileSystem, null), Times.Once());
commandRuntimeMock.Verify(f => f.WriteObject(true), Times.Never());
}
public TClient CreateClient <TClient>(IAzureContextContainer profile, IAzureSubscription subscription, string endpoint) where TClient : ServiceClient <TClient>
{
#if !NETSTANDARD
if (subscription == null)
{
throw new ArgumentException(Microsoft.Azure.Commands.ResourceManager.Common.Properties.Resources.InvalidDefaultSubscription);
}
if (profile == null)
{
profile = new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription.Id.ToString(), "fake_token");
if (HttpMockServer.GetCurrentMode() != HttpRecorderMode.Playback)
{
ProfileClient profileClient = new ProfileClient(profile as AzureSMProfile);
AzureContext context = new AzureContext(
subscription,
profileClient.GetAccount(subscription.GetAccount()),
profileClient.GetEnvironmentOrDefault(subscription.GetEnvironment())
);
creds = AzureSession.Instance.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
}
Uri endpointUri = profile.Environments.FirstOrDefault((e) => e.Name.Equals(subscription.GetEnvironment(), StringComparison.OrdinalIgnoreCase)).GetEndpointAsUri(endpoint);
return(CreateCustomClient <TClient>(creds, endpointUri));
#else
throw new NotSupportedException("AzureSMProfile is not supported in Azure PS on .Net Core.");
#endif
}
public void ProcessStopWebsiteTest()
{
const string websiteName = "website1";
// Setup
Mock <IWebsitesClient> websitesClientMock = new Mock <IWebsitesClient>();
websitesClientMock.Setup(f => f.StopWebsite(websiteName, null));
// Test
StopAzureWebsiteCommand stopAzureWebsiteCommand = new StopAzureWebsiteCommand()
{
CommandRuntime = new MockCommandRuntime(),
Name = websiteName,
WebsitesClient = websitesClientMock.Object
};
currentProfile = new AzureSMProfile();
var subscription = new AzureSubscription {
Id = base.subscriptionId
};
subscription.SetDefault();
currentProfile.SubscriptionTable[new Guid(base.subscriptionId)] = subscription;
stopAzureWebsiteCommand.ExecuteCmdlet();
websitesClientMock.Verify(f => f.StopWebsite(websiteName, null), Times.Once());
}
