public void Initialize(string className)
{
if (initialized)
return;
if (HttpMockServer.GetCurrentMode() == HttpRecorderMode.Record)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var resourcesClient = TestBase.GetServiceClient<ResourceManagementClient>(testFactory);
var mgmtClient = TestBase.GetServiceClient<KeyVaultManagementClient>(testFactory);
var tenantId = testEnv.AuthorizationContext.TenantId;
//Figure out which locations are available for Key Vault
location = GetKeyVaultLocation(resourcesClient);
//Create a resource group in that location
preCreatedVault = TestUtilities.GenerateName("pshtestvault");
resourceGroupName = TestUtilities.GenerateName("pshtestrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup { Location = location });
var createResponse = CreateVault(mgmtClient, location, tenantId);
}
initialized = true;
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action<CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName, string tenant)
{
Dictionary<string, string> d = new Dictionary<string, string>();
d.Add("Microsoft.Resources", null);
d.Add("Microsoft.Features", null);
d.Add("Microsoft.Authorization", null);
var providersToIgnore = new Dictionary<string, string>();
providersToIgnore.Add("Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(true, d, providersToIgnore);
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var oldFactory = AzureSession.AuthenticationFactory as MockTokenAuthenticationFactory;
AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(oldFactory.Token.UserId, oldFactory.Token.AccessToken, tenant);
var callingClassName = callingClassType
.Split(new[] {"."}, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
callingClassName + ".ps1",
helper.RMProfileModule);
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
/// <summary>
/// This overrides the default subscription and default account. This allows the
/// test to get the tenant id in the test.
/// </summary>
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);
// Existing test will not have a user or tenant id set
if (tenantId != null && user != null)
{
var testSubscription = new AzureSubscription()
{
Id = new Guid(csmEnvironment.SubscriptionId),
Name = AzureRmProfileProvider.Instance.Profile.Context.Subscription.Name,
Environment = AzureRmProfileProvider.Instance.Profile.Context.Subscription.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
},
}
};
AzureRmProfileProvider.Instance.Profile.Context.Subscription.Name = testSubscription.Name;
AzureRmProfileProvider.Instance.Profile.Context.Subscription.Id = testSubscription.Id;
AzureRmProfileProvider.Instance.Profile.Context.Subscription.Account = testSubscription.Account;
var environment = AzureRmProfileProvider.Instance.Profile.Environments[AzureRmProfileProvider.Instance.Profile.Context.Subscription.Environment];
environment.Endpoints[AzureEnvironment.Endpoint.Graph] = csmEnvironment.Endpoints.GraphUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.StorageEndpointSuffix] = "core.windows.net";
AzureRmProfileProvider.Instance.Profile.Save();
}
}
}
/// <summary>
/// Default constructor for management clients, using the TestSupport Infrastructure
/// </summary>
/// <param name="testBase">the test class</param>
/// <returns>A site recovery management client, created from the current context (environment variables)</returns>
public static SiteRecoveryManagementClient GetSiteRecoveryManagementClient(this TestBase testBase)
{
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback =
IgnoreCertificateErrorHandler;
}
TestEnvironment environment = new CSMTestEnvironmentFactory().GetTestEnvironment();
// TestEnvironment environment = new RDFETestEnvironmentFactory().GetTestEnvironment();
// environment.BaseUri = new Uri("https://localhost:8443/Rdfeproxy.svc");
// environment.BaseUri = new Uri("https://sea-bvtd2-srs1-t56tl.cloudapp.net");
SiteRecoveryTestsBase.MyCloudService = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"RecoveryServices-WHNOWF6LI6NM4B55QDIYR3YG3YAEZNTDUOWHPQX7NJB2LHDGTXJA-West-US" :
Environment.GetEnvironmentVariable("CLOUD_SERVICE_NAME");
SiteRecoveryTestsBase.MyVaultName = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"hydratest" :
Environment.GetEnvironmentVariable("RESOURCE_NAME");
SiteRecoveryTestsBase.VaultKey = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"loMUdckuT9SEvpQKcSG07A==" :
Environment.GetEnvironmentVariable("CHANNEL_INTEGRITY_KEY");
SiteRecoveryTestsBase.MyResourceGroupName = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"RecoveryServices-WHNOWF6LI6NM4B55QDIYR3YG3YAEZNTDUOWHPQX7NJB2LHDGTXJA-West-US" :
Environment.GetEnvironmentVariable("RESOURCE_GROUP_NAME");
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyCloudService))
{
throw new Exception("Please set CLOUD_SERVICE_NAME" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyVaultName))
{
throw new Exception("Please set RESOURCE_NAME" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.VaultKey))
{
throw new Exception("Please set CHANNEL_INTEGRITY_KEY" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyResourceGroupName))
{
throw new Exception("Please set RESOURCE_GROUP_NAME" +
" environment variable before running the tests in Live mode");
}
return new SiteRecoveryManagementClient(
SiteRecoveryTestsBase.MyVaultName,
SiteRecoveryTestsBase.MyResourceGroupName,
"Microsoft.SiteRecoveryBVTD2",
"SiteRecoveryVault",
(SubscriptionCloudCredentials)environment.Credentials,
environment.BaseUri).WithHandler(HttpMockServer.CreateInstance());
}
/// <summary>
/// Default constructor for management clients, using the TestSupport Infrastructure
/// </summary>
/// <param name="testBase">the test class</param>
/// <returns>A site recovery management client, created from the current context (environment variables)</returns>
public static SiteRecoveryManagementClient GetSiteRecoveryManagementClient(this TestBase testBase)
{
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback =
IgnoreCertificateErrorHandler;
}
TestEnvironment environment = new CSMTestEnvironmentFactory().GetTestEnvironment();
//TestEnvironment environment = new RDFETestEnvironmentFactory().GetTestEnvironment();
//environment.BaseUri = new Uri("https://localhost:8443/Rdfeproxy.svc");
// environment.BaseUri = new Uri("https://sea-bvtd2-srs1-t56tl.cloudapp.net");
SiteRecoveryTestsBase.MyCloudService = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"rg1" :
Environment.GetEnvironmentVariable("CLOUD_SERVICE_NAME");
SiteRecoveryTestsBase.MyVaultName = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"S91-1-2-3-4-5" :
Environment.GetEnvironmentVariable("RESOURCE_NAME");
SiteRecoveryTestsBase.VaultKey = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"8dr012Ze+WIPM5z1xSNGZA==" :
Environment.GetEnvironmentVariable("CHANNEL_INTEGRITY_KEY");
SiteRecoveryTestsBase.MyResourceGroupName = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"S91-1" :
Environment.GetEnvironmentVariable("RESOURCE_GROUP_NAME");
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyCloudService))
{
throw new Exception("Please set CLOUD_SERVICE_NAME" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyVaultName))
{
throw new Exception("Please set RESOURCE_NAME" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.VaultKey))
{
throw new Exception("Please set CHANNEL_INTEGRITY_KEY" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyResourceGroupName))
{
throw new Exception("Please set RESOURCE_GROUP_NAME" +
" environment variable before running the tests in Live mode");
}
return new SiteRecoveryManagementClient(
SiteRecoveryTestsBase.MyVaultName,
SiteRecoveryTestsBase.MyResourceGroupName,
"Microsoft.RecoveryServicesBVTD2",
"vaults",
(SubscriptionCloudCredentials)environment.Credentials,
environment.BaseUri).WithHandler(HttpMockServer.CreateInstance());
}
/// <summary>
/// Default constructor for management clients, using the TestSupport Infrastructure
/// </summary>
/// <param name="testBase">the test class</param>
/// <returns>A site recovery management client, created from the current context (environment variables)</returns>
public static SiteRecoveryManagementClient GetSiteRecoveryManagementClient(this TestBase testBase)
{
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback =
IgnoreCertificateErrorHandler;
}
TestEnvironment environment = new CSMTestEnvironmentFactory().GetTestEnvironment();
SiteRecoveryTestsBase.MyCloudService = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"testsitegroup" :
Environment.GetEnvironmentVariable("CLOUD_SERVICE_NAME");
SiteRecoveryTestsBase.MyVaultName = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"ppeVault2" :
Environment.GetEnvironmentVariable("RESOURCE_NAME");
SiteRecoveryTestsBase.VaultKey = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"tmPfTki5UFSdaEq2JFvzuw==" :
Environment.GetEnvironmentVariable("CHANNEL_INTEGRITY_KEY");
SiteRecoveryTestsBase.MyResourceGroupName = (HttpMockServer.Mode == HttpRecorderMode.Playback) ?
"testsitegroup" :
Environment.GetEnvironmentVariable("RESOURCE_GROUP_NAME");
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyCloudService))
{
throw new Exception("Please set CLOUD_SERVICE_NAME" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyVaultName))
{
throw new Exception("Please set RESOURCE_NAME" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.VaultKey))
{
throw new Exception("Please set CHANNEL_INTEGRITY_KEY" +
" environment variable before running the tests in Live mode");
}
if (string.IsNullOrEmpty(SiteRecoveryTestsBase.MyResourceGroupName))
{
throw new Exception("Please set RESOURCE_GROUP_NAME" +
" environment variable before running the tests in Live mode");
}
return new SiteRecoveryManagementClient(
SiteRecoveryTestsBase.MyVaultName,
SiteRecoveryTestsBase.MyResourceGroupName,
"Microsoft.SiteRecovery",
(SubscriptionCloudCredentials)environment.Credentials,
environment.BaseUri).WithHandler(HttpMockServer.CreateInstance());
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action initialize,
Action cleanup,
string callingClassType,
string mockName)
{
Dictionary<string, string> d = new Dictionary<string, string>();
d.Add("Microsoft.Authorization", "2014-07-01-preview");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(false, d);
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = SetupCSMTestEnvironmentFactory();
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
"Microsoft.Azure.Commands.Batch.Test.dll",
helper.RMProfileModule,
helper.RMResourceModule,
helper.GetRMModulePath("AzureRM.Batch.psd1"));
try
{
if (initialize != null)
{
initialize();
}
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
public static SearchServiceClient GetSearchServiceClient(this SearchServiceFixture fixture)
{
var factory = new CSMTestEnvironmentFactory();
TestEnvironment currentEnvironment = factory.GetTestEnvironment();
Uri baseUri = currentEnvironment.GetBaseSearchUri(ExecutionMode.CSM, fixture.SearchServiceName);
SearchServiceClient client =
new SearchServiceClient(new SearchCredentials(fixture.PrimaryApiKey), baseUri);
return TestBaseCopy.AddMockHandler<SearchServiceClient>(ref client);
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action<CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if(initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
helper.RMProfileModule,
helper.RMResourceModule,
helper.GetRMModulePath("AzureRM.Network.psd1"));
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if(cleanup !=null)
{
cleanup();
}
}
}
}
public void RunPsTestWorkflow(
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName, string tenant)
{
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var oldFactory = AzureSession.AuthenticationFactory as MockTokenAuthenticationFactory;
AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(oldFactory.Token.UserId, oldFactory.Token.AccessToken, tenant);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
callingClassName + ".ps1",
helper.RMProfileModule);
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
public void RunPsTestWorkflow(
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
HttpMockServer.RecordsDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SessionRecords");
using (MockContext context = MockContext.Start(callingClassType, mockName))
{
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients(context);
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\" + callingClassName + ".ps1",
helper.RMProfileModule,
helper.RMResourceModule,
helper.GetRMModulePath(@"AzureRM.DeviceProvisioningServices.psd1"),
helper.GetRMModulePath(@"AzureRM.IotHub.psd1"),
"AzureRM.Resources.ps1"
);
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action<CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName, string tenant)
{
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var oldFactory = AzureSession.AuthenticationFactory as MockTokenAuthenticationFactory;
AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(oldFactory.Token.UserId, oldFactory.Token.AccessToken, tenant);
var callingClassName = callingClassType
.Split(new[] {"."}, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
callingClassName + ".ps1",
helper.RMProfileModule);
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
public void RunPsTestWorkflow(
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(
AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
"ResourceManagerStartup.ps1");
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action initialize,
Action cleanup,
string callingClassType,
string mockName)
{
HttpMockServer.Matcher = new PermissiveRecordMatcher();
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = SetupCSMTestEnvironmentFactory();
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(
AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
"Microsoft.Azure.Commands.Batch.Test.dll"
);
try
{
if (initialize != null)
{
initialize();
}
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
/// <summary>
/// Default constructor for management clients, using the TestSupport Infrastructure
/// </summary>
/// <param name="testBase">the test class</param>
/// <returns>A recovery services management client, created from the current context (environment variables)</returns>
public static RecoveryServicesManagementClient GetRecoveryServicesManagementClient(this TestBase testBase)
{
TestEnvironment environment = new CSMTestEnvironmentFactory().GetTestEnvironment();
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback =
IgnoreCertificateErrorHandler;
}
return new RecoveryServicesManagementClient(
(SubscriptionCloudCredentials)environment.Credentials,
environment.BaseUri).WithHandler(HttpMockServer.CreateInstance());
}
/// <summary>
/// Default constructor for management clients, using the TestSupport Infrastructure
/// </summary>
/// <param name="testBase">the test class</param>
/// <returns>A recovery services management client, created from the current context (environment variables)</returns>
public static RecoveryServicesManagementClient GetRecoveryServicesManagementClient(this TestBase testBase)
{
TestEnvironment environment = new CSMTestEnvironmentFactory().GetTestEnvironment();
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback =
IgnoreCertificateErrorHandler;
}
return(new RecoveryServicesManagementClient(
(SubscriptionCloudCredentials)environment.Credentials,
environment.BaseUri).WithHandler(HttpMockServer.CreateInstance()));
}
private SearchIndexClient GetSearchIndexClientForKey(string indexName, string apiKey)
{
var factory = new CSMTestEnvironmentFactory();
TestEnvironment currentEnvironment = factory.GetTestEnvironment();
Uri baseUri =
new Uri(
currentEnvironment.GetBaseSearchUri(ExecutionMode.CSM, SearchServiceName),
String.Format("indexes/{0}/", indexName));
SearchIndexClient client = new SearchIndexClient(new SearchCredentials(apiKey), baseUri);
return(TestBaseCopy.AddMockHandler <SearchIndexClient>(ref client));
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (HttpMockServer.Mode == HttpRecorderMode.Record && initialized)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var resourcesClient = TestBase.GetServiceClient <ResourceManagementClient>(testFactory);
resourcesClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
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();
}
}
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();
}
}
public static void RefreshAccessToken(this ApiManagementClient apiManagementClient)
{
if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
// if it's playback then do nothing
return;
}
var testEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
var context = new AuthenticationContext(new Uri(testEnvironment.Endpoints.AADAuthUri, testEnvironment.Tenant).AbsoluteUri);
var result = context.AcquireToken("https://management.core.windows.net/", testEnvironment.ClientId, new Uri("urn:ietf:wg:oauth:2.0:oob"), PromptBehavior.Auto);
var newToken = context.AcquireTokenByRefreshToken(result.RefreshToken, testEnvironment.ClientId, "https://management.core.windows.net/");
((TokenCloudCredentials) apiManagementClient.Credentials).Token = newToken.AccessToken;
}
public static void RefreshAccessToken(this ApiManagementClient apiManagementClient)
{
if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
// if it's playback then do nothing
return;
}
var testEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
var context = new AuthenticationContext(new Uri(testEnvironment.Endpoints.AADAuthUri, testEnvironment.Tenant).AbsoluteUri);
var result = context.AcquireToken("https://management.core.windows.net/", testEnvironment.ClientId, new Uri("urn:ietf:wg:oauth:2.0:oob"), PromptBehavior.Auto);
var newToken = context.AcquireTokenByRefreshToken(result.RefreshToken, testEnvironment.ClientId, "https://management.core.windows.net/");
((TokenCloudCredentials)apiManagementClient.Credentials).Token = newToken.AccessToken;
}
public void Dispose()
{
if (HttpMockServer.Mode == HttpRecorderMode.Record && !fromConfig)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var mgmtClient = TestBase.GetServiceClient <KeyVaultManagementClient>(testFactory);
var resourcesClient = TestBase.GetServiceClient <ResourceManagementClient>(testFactory);
var tenantId = testEnv.AuthorizationContext.TenatId;
var graphClient = TestBase.GetGraphServiceClient <GraphRbacManagementClient>(testFactory, tenantId);
mgmtClient.Vaults.Delete(rgName, vaultName);
graphClient.Application.Delete(appObjectId);
resourcesClient.ResourceGroups.Delete(rgName);
}
}
protected void RunPowerShellTest(params string[] scripts)
{
using (UndoContext context = UndoContext.Current)
{
context.Start(TestUtilities.GetCallingClass(2), TestUtilities.GetCurrentMethodName(2));
this.armTestFactory = new CSMTestEnvironmentFactory();
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureServiceManagement);
helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\" + this.GetType().Name + ".ps1");
helper.RunPowerShellTest(scripts);
}
}
/// <summary>
/// This overrides the default subscription and default account. This allows the
/// test to get the tenant id in the test.
/// </summary>
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);
// Existing test will not have a user or tenant id set
if (tenantId != null && user != null)
{
var testSubscription = new AzureSubscription()
{
Id = csmEnvironment.SubscriptionId,
Name = AzureRmProfileProvider.Instance.Profile.DefaultContext.Subscription.Name,
};
testSubscription.SetAccount(user);
testSubscription.SetEnvironment(AzureRmProfileProvider.Instance.Profile.DefaultContext.Subscription.GetEnvironment());
testSubscription.SetDefault();
testSubscription.SetStorageAccount(Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT"));
testSubscription.SetTenant(tenantId);
var testAccount = new AzureAccount()
{
Id = user,
Type = AzureAccount.AccountType.User,
};
testAccount.SetSubscriptions(csmEnvironment.SubscriptionId);
AzureRmProfileProvider.Instance.Profile.DefaultContext.Subscription.Name = testSubscription.Name;
AzureRmProfileProvider.Instance.Profile.DefaultContext.Subscription.Id = testSubscription.Id;
AzureRmProfileProvider.Instance.Profile.DefaultContext.Subscription.SetAccount(testSubscription.GetAccount());
var environment = AzureRmProfileProvider.Instance.Profile.GetEnvironment(AzureRmProfileProvider.Instance.Profile.DefaultContext.Subscription.GetEnvironment());
environment.SetEndpoint(AzureEnvironment.Endpoint.Graph, csmEnvironment.Endpoints.GraphUri.AbsoluteUri);
environment.SetEndpoint(AzureEnvironment.Endpoint.StorageEndpointSuffix, "core.windows.net");
AzureRmProfileProvider.Instance.GetProfile <AzureRmProfile>().Save();
}
}
}
public KeyVaultTestBase()
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
this.client = GetServiceClient <KeyVaultManagementClient>(testFactory);
this.resourcesClient = GetServiceClient <ResourceManagementClient>(testFactory);
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
this.tenantId = testEnv.AuthorizationContext.TenantId;
this.subscriptionId = testEnv.SubscriptionId;
var graphClient = GetGraphServiceClient <GraphRbacManagementClient>(testFactory, tenantId);
this.objectId = graphClient.User.Get(testEnv.AuthorizationContext.UserId).User.ObjectId;
this.applicationId = Guid.NewGuid().ToString();
HttpMockServer.Variables[TenantIdKey] = tenantId;
HttpMockServer.Variables[ObjectIdKey] = objectId;
HttpMockServer.Variables[SubIdKey] = subscriptionId;
HttpMockServer.Variables[ApplicationIdKey] = applicationId;
}
else if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
tenantId = HttpMockServer.Variables[TenantIdKey];
objectId = HttpMockServer.Variables[ObjectIdKey];
subscriptionId = HttpMockServer.Variables[SubIdKey];
applicationId = HttpMockServer.Variables[ApplicationIdKey];
}
var providers = resourcesClient.Providers.Get("Microsoft.KeyVault");
this.location = providers.Provider.ResourceTypes.Where(
(resType) =>
{
if (resType.Name == "vaults")
{
return(true);
}
else
{
return(false);
}
}
).First().Locations.FirstOrDefault();
}
public void Initialize(string className)
{
if (initialized)
{
return;
}
HttpMockServer server;
try
{
server = HttpMockServer.CreateInstance();
}
catch (ApplicationException)
{
// mock server has never been initialized, we will need to initialize it.
HttpMockServer.Initialize(className, "InitialCreation");
server = HttpMockServer.CreateInstance();
}
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var resourcesClient = TestBase.GetServiceClient <ResourceManagementClient>(testFactory);
var mgmtClient = TestBase.GetServiceClient <KeyVaultManagementClient>(testFactory);
var tenantId = testEnv.AuthorizationContext.TenantId;
//Figure out which locations are available for Key Vault
location = GetKeyVaultLocation(resourcesClient);
//Create a resource group in that location
preCreatedVault = TestUtilities.GenerateName("pshtestvault");
resourceGroupName = TestUtilities.GenerateName("pshtestrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup {
Location = location
});
var createResponse = CreateVault(mgmtClient, location, tenantId);
}
initialized = true;
}
public KeyVaultTestBase()
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
this.client = GetServiceClient<KeyVaultManagementClient>(testFactory);
this.resourcesClient = GetServiceClient<ResourceManagementClient>(testFactory);
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
this.tenantId = testEnv.AuthorizationContext.TenatId;
this.subscriptionId = testEnv.SubscriptionId;
var graphClient = GetGraphServiceClient<GraphRbacManagementClient>(testFactory, tenantId);
this.objectId = graphClient.User.Get(testEnv.AuthorizationContext.UserId).User.ObjectId;
this.applicationId = Guid.NewGuid().ToString();
HttpMockServer.Variables[TenantIdKey] = tenantId;
HttpMockServer.Variables[ObjectIdKey] = objectId;
HttpMockServer.Variables[SubIdKey] = subscriptionId;
HttpMockServer.Variables[ApplicationIdKey] = applicationId;
}
else if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
tenantId = HttpMockServer.Variables[TenantIdKey];
objectId = HttpMockServer.Variables[ObjectIdKey];
subscriptionId = HttpMockServer.Variables[SubIdKey];
applicationId = HttpMockServer.Variables[ApplicationIdKey];
}
var providers = resourcesClient.Providers.Get("Microsoft.KeyVault");
this.location = providers.Provider.ResourceTypes.Where(
(resType) =>
{
if (resType.Name == "vaults")
return true;
else
return false;
}
).First().Locations.FirstOrDefault();
}
public void Initialize(string className)
{
if (initialized)
return;
HttpMockServer server;
try
{
server = HttpMockServer.CreateInstance();
}
catch (ApplicationException)
{
// mock server has never been initialized, we will need to initialize it.
HttpMockServer.Initialize(className, "InitialCreation");
server = HttpMockServer.CreateInstance();
}
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var resourcesClient = TestBase.GetServiceClient<ResourceManagementClient>(testFactory);
var mgmtClient = TestBase.GetServiceClient<KeyVaultManagementClient>(testFactory);
var tenantId = testEnv.AuthorizationContext.TenantId;
//Figure out which locations are available for Key Vault
location = GetKeyVaultLocation(resourcesClient);
//Create a resource group in that location
preCreatedVault = TestUtilities.GenerateName("pshtestvault");
resourceGroupName = TestUtilities.GenerateName("pshtestrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup { Location = location });
var createResponse = CreateVault(mgmtClient, location, tenantId);
}
initialized = true;
}
/// <summary>
/// Default constructor for management clients, using the TestSupport Infrastructure
/// </summary>
/// <param name="testBase">the test class</param>
/// <returns>A site recovery management client, created from the current context (environment variables)</returns>
public static SiteRecoveryManagementClient GetSiteRecoveryManagementClient(this TestBase testBase, String scenario = "")
{
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback =
IgnoreCertificateErrorHandler;
}
TestEnvironment environment = new CSMTestEnvironmentFactory().GetTestEnvironment();
switch (scenario)
{
case Constants.A2A:
SiteRecoveryTestsBase.MyVaultName = "integrationTest1";
SiteRecoveryTestsBase.MyResourceGroupName = "rg1";
SiteRecoveryTestsBase.ResourceNamespace = "Microsoft.RecoveryServicesBVTD2";
SiteRecoveryTestsBase.ResourceType = "RecoveryServicesVault";
environment.BaseUri = new Uri("https://sriramvu:8443/Rdfeproxy.svc");
break;
default:
SiteRecoveryTestsBase.MyVaultName = "hydratest";
SiteRecoveryTestsBase.VaultKey = "loMUdckuT9SEvpQKcSG07A==";
SiteRecoveryTestsBase.MyResourceGroupName = "RecoveryServices-WHNOWF6LI6NM4B55QDIYR3YG3YAEZNTDUOWHPQX7NJB2LHDGTXJA-West-US";
SiteRecoveryTestsBase.ResourceNamespace = "Microsoft.SiteRecoveryBVTD2";
SiteRecoveryTestsBase.ResourceType = "SiteRecoveryVault";
break;
}
;
return(new SiteRecoveryManagementClient(
SiteRecoveryTestsBase.MyVaultName,
SiteRecoveryTestsBase.MyResourceGroupName,
SiteRecoveryTestsBase.ResourceNamespace,
SiteRecoveryTestsBase.ResourceType,
(SubscriptionCloudCredentials)environment.Credentials,
environment.BaseUri).WithHandler(HttpMockServer.CreateInstance()));
}
/// <summary>
/// Default constructor for management clients, using the TestSupport Infrastructure
/// </summary>
/// <param name="testBase">the test class</param>
/// <returns>A site recovery management client, created from the current context (environment variables)</returns>
public static SiteRecoveryManagementClient GetSiteRecoveryManagementClient(this TestBase testBase, String scenario = "")
{
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
ServicePointManager.ServerCertificateValidationCallback =
IgnoreCertificateErrorHandler;
}
TestEnvironment environment = new CSMTestEnvironmentFactory().GetTestEnvironment();
switch(scenario)
{
case Constants.A2A:
SiteRecoveryTestsBase.MyVaultName = "integrationTest1";
SiteRecoveryTestsBase.MyResourceGroupName = "rg1";
SiteRecoveryTestsBase.ResourceNamespace = "Microsoft.RecoveryServicesBVTD2";
SiteRecoveryTestsBase.ResourceType = "RecoveryServicesVault";
environment.BaseUri = new Uri("https://sriramvu:8443/Rdfeproxy.svc");
break;
default:
SiteRecoveryTestsBase.MyVaultName = "hydratest";
SiteRecoveryTestsBase.VaultKey = "loMUdckuT9SEvpQKcSG07A==";
SiteRecoveryTestsBase.MyResourceGroupName = "RecoveryServices-WHNOWF6LI6NM4B55QDIYR3YG3YAEZNTDUOWHPQX7NJB2LHDGTXJA-West-US";
SiteRecoveryTestsBase.ResourceNamespace = "Microsoft.SiteRecoveryBVTD2";
SiteRecoveryTestsBase.ResourceType = "SiteRecoveryVault";
break;
};
return new SiteRecoveryManagementClient(
SiteRecoveryTestsBase.MyVaultName,
SiteRecoveryTestsBase.MyResourceGroupName,
SiteRecoveryTestsBase.ResourceNamespace,
SiteRecoveryTestsBase.ResourceType,
(SubscriptionCloudCredentials)environment.Credentials,
environment.BaseUri).WithHandler(HttpMockServer.CreateInstance());
}
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 context = AzureRmProfileProvider.Instance.Profile.DefaultContext;
var testSubscription = new AzureSubscription()
{
Id = csmEnvironment.SubscriptionId,
Name = context.Subscription.Name
};
testSubscription.SetEnvironment(context.Environment.Name);
testSubscription.SetAccount(user);
testSubscription.SetDefault();
testSubscription.SetStorageAccount(Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT"));
testSubscription.SetTenant(tenantId);
var testAccount = new AzureAccount()
{
Id = user,
Type = AzureAccount.AccountType.User
};
testAccount.SetSubscriptions(csmEnvironment.SubscriptionId);
AzureRmProfileProvider.Instance.Profile.DefaultContext = new AzureContext(testSubscription, testAccount, context.Environment, new AzureTenant {
Id = tenantId
});
}
}
public GraphTestBase()
{
var testFactory = new CSMTestEnvironmentFactory();
TestEnvironment environment = testFactory.GetTestEnvironment();
string tenantId = null;
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
tenantId = environment.AuthorizationContext.TenantId;
Domain = environment.AuthorizationContext.UserId
.Split(new [] {"@"}, StringSplitOptions.RemoveEmptyEntries)
.Last();
HttpMockServer.Variables[TenantIdKey] = tenantId;
HttpMockServer.Variables[DomainKey] = Domain;
}
else if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
tenantId = HttpMockServer.Variables[TenantIdKey];
Domain = HttpMockServer.Variables[DomainKey];
}
GraphClient = TestBase.GetGraphServiceClient<GraphRbacManagementClient>(testFactory, tenantId);
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action<CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
var d = new Dictionary<string, string>();
d.Add("Microsoft.Resources", null);
d.Add("Microsoft.Features", null);
d.Add("Microsoft.Authorization", null);
d.Add("Microsoft.Compute", null);
var providersToIgnore = new Dictionary<string, string>();
providersToIgnore.Add("Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(true, d, providersToIgnore);
HttpMockServer.RecordsDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SessionRecords");
using (var context = MockContext.Start(callingClassType, mockName))
{
_csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(_csmTestFactory);
}
SetupManagementClients(context);
_helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
_helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
_helper.RMProfileModule,
_helper.RMResourceModule,
@"AzureRM.Cdn.psd1");
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
_helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
public void RunPsTestWorkflow(
PsBackupProviderTypes providerType,
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
Dictionary <string, string> providers = new Dictionary <string, string>();
providers.Add("Microsoft.Resources", null);
providers.Add("Microsoft.Features", null);
providers.Add("Microsoft.Authorization", null);
providers.Add("Microsoft.Compute", null);
var providersToIgnore = new Dictionary <string, string>();
providersToIgnore.Add("Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(true, providers, providersToIgnore);
HttpMockServer.RecordsDirectory =
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SessionRecords");
using (RestTestFramework.MockContext context =
RestTestFramework.MockContext.Start(callingClassType, mockName))
{
csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize.Invoke(csmTestFactory);
}
SetupManagementClients(context);
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var testFolderName = providerType.ToString();
var callingClassName =
callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries).Last();
string psFile =
"ScenarioTests\\" + testFolderName + "\\" + callingClassName + ".ps1";
string commonPsFile = "ScenarioTests\\" + testFolderName + "\\Common.ps1";
string rmProfileModule = helper.RMProfileModule;
string rmModulePath = helper.GetRMModulePath("AzureRM.RecoveryServices.Backup.psd1");
string recoveryServicesModulePath =
helper.GetRMModulePath("AzureRM.RecoveryServices.psd1");
List <string> modules = new List <string>();
if (File.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, commonPsFile)))
{
modules.Add(commonPsFile);
}
modules.Add(psFile);
modules.Add(rmProfileModule);
modules.Add(rmModulePath);
modules.Add(recoveryServicesModulePath);
helper.SetupModules(AzureModule.AzureResourceManager, modules.ToArray());
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup.Invoke();
}
}
}
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment currentEnvironment = null;
if (mode == AzureModule.AzureResourceManager)
{
#if !NETSTANDARD
currentEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
#else
currentEnvironment = TestEnvironmentFactory.GetTestEnvironment();
#endif
}
else
{
#if !NETSTANDARD
currentEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
#else
throw new NotSupportedException("RDFE environment is not supported in .Net Core");
#endif
}
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
SetAuthenticationFactory(mode, currentEnvironment);
AzureEnvironment environment = new AzureEnvironment {
Name = testEnvironmentName
};
Debug.Assert(currentEnvironment != null);
environment.ActiveDirectoryAuthority = currentEnvironment.Endpoints.AADAuthUri.AbsoluteUri;
environment.GalleryUrl = currentEnvironment.Endpoints.GalleryUri.AbsoluteUri;
environment.ServiceManagementUrl = currentEnvironment.BaseUri.AbsoluteUri;
environment.ResourceManagerUrl = currentEnvironment.Endpoints.ResourceManagementUri.AbsoluteUri;
environment.GraphUrl = currentEnvironment.Endpoints.GraphUri.AbsoluteUri;
environment.AzureDataLakeAnalyticsCatalogAndJobEndpointSuffix = currentEnvironment.Endpoints.DataLakeAnalyticsJobAndCatalogServiceUri.OriginalString.Replace("https://", ""); // because it is just a sufix
environment.AzureDataLakeStoreFileSystemEndpointSuffix = currentEnvironment.Endpoints.DataLakeStoreServiceUri.OriginalString.Replace("https://", ""); // because it is just a sufix
#if !NETSTANDARD
if (!ProfileClient.Profile.EnvironmentTable.ContainsKey(testEnvironmentName))
{
ProfileClient.AddOrSetEnvironment(environment);
}
#endif
if (!AzureRmProfileProvider.Instance.GetProfile <AzureRmProfile>().EnvironmentTable.ContainsKey(testEnvironmentName))
{
AzureRmProfileProvider.Instance.GetProfile <AzureRmProfile>().EnvironmentTable[testEnvironmentName] = environment;
}
if (currentEnvironment.SubscriptionId != null)
{
testSubscription = new AzureSubscription()
{
Id = currentEnvironment.SubscriptionId,
Name = testSubscriptionName,
};
testSubscription.SetEnvironment(testEnvironmentName);
testSubscription.SetAccount(currentEnvironment.UserName);
testSubscription.SetDefault();
testSubscription.SetStorageAccount(Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT"));
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
};
testAccount.SetSubscriptions(currentEnvironment.SubscriptionId);
#if !NETSTANDARD
ProfileClient.Profile.SubscriptionTable[testSubscription.GetId()] = testSubscription;
ProfileClient.Profile.AccountTable[testAccount.Id] = testAccount;
ProfileClient.SetSubscriptionAsDefault(testSubscription.Name, testSubscription.GetAccount());
#endif
var testTenant = new AzureTenant()
{
Id = Guid.NewGuid().ToString()
};
if (!string.IsNullOrEmpty(currentEnvironment.Tenant))
{
Guid tenant;
if (Guid.TryParse(currentEnvironment.Tenant, out tenant))
{
testTenant.Id = currentEnvironment.Tenant;
}
}
AzureRmProfileProvider.Instance.Profile.DefaultContext = new AzureContext(testSubscription, testAccount, environment, testTenant);
}
}
private CSMTestEnvironmentFactory SetupCSMTestEnvironmentFactory()
{
CSMTestEnvironmentFactory factory = new CSMTestEnvironmentFactory();
// to set test environment to Current add Environment=Current in TEST_CSM_ORGID_AUTHENTICATION env. variable
// available configurations are: Prod/Dogfood/Next/Current
return factory;
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action<CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
Dictionary<string, string> d = new Dictionary<string, string>();
d.Add("Microsoft.Authorization", null);
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(false, d);
using (RestTestFramework.MockContext context = RestTestFramework.MockContext.Start(callingClassType, mockName))
{
this.csmTestFactory = new CSMTestEnvironmentFactory();
if(initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients(context);
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\ComputeTestCommon.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
helper.RMProfileModule,
helper.RMResourceModule,
helper.RMStorageDataPlaneModule,
helper.RMStorageModule,
helper.GetRMModulePath("AzureRM.Compute.psd1"),
helper.GetRMModulePath("AzureRM.Network.psd1"));
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if(cleanup !=null)
{
cleanup();
}
}
}
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment rdfeEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
TestEnvironment csmEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
TestEnvironment currentEnvironment = (mode == AzureModule.AzureResourceManager ? csmEnvironment : rdfeEnvironment);
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
SetAuthenticationFactory(mode, rdfeEnvironment, csmEnvironment);
AzureEnvironment environment = new AzureEnvironment {
Name = testEnvironmentName
};
Debug.Assert(currentEnvironment != null);
environment.Endpoints[AzureEnvironment.Endpoint.ActiveDirectory] = currentEnvironment.Endpoints.AADAuthUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Gallery] = currentEnvironment.Endpoints.GalleryUri.AbsoluteUri;
if (csmEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ResourceManager] = csmEnvironment.BaseUri.AbsoluteUri;
}
if (rdfeEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ServiceManagement] = rdfeEnvironment.BaseUri.AbsoluteUri;
}
if (!ProfileClient.Profile.Environments.ContainsKey(testEnvironmentName))
{
ProfileClient.AddOrSetEnvironment(environment);
}
if (currentEnvironment.SubscriptionId != null)
{
testSubscription = new AzureSubscription()
{
Id = new Guid(currentEnvironment.SubscriptionId),
Name = testSubscriptionName,
Environment = testEnvironmentName,
Account = currentEnvironment.UserName,
Properties = new Dictionary <AzureSubscription.Property, string>
{
{ AzureSubscription.Property.Default, "True" },
{
AzureSubscription.Property.StorageAccount,
Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")
},
}
};
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary <AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, currentEnvironment.SubscriptionId },
}
};
ProfileClient.Profile.Subscriptions[testSubscription.Id] = testSubscription;
ProfileClient.Profile.Accounts[testAccount.Id] = testAccount;
ProfileClient.SetSubscriptionAsDefault(testSubscription.Name, testSubscription.Account);
}
}
public void RunPsTestWorkflow(
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
Dictionary <string, string> d = new Dictionary <string, string>();
d.Add("Microsoft.Resources", null);
d.Add("Microsoft.Features", null);
d.Add("Microsoft.Authorization", null);
d.Add("Microsoft.Compute", null);
var providersToIgnore = new Dictionary <string, string>();
providersToIgnore.Add("Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(true, d, providersToIgnore);
HttpMockServer.RecordsDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SessionRecords");
using (MockContext context = MockContext.Start(callingClassType, mockName))
{
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients(context);
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
helper.RMProfileModule,
helper.RMResourceModule,
helper.GetRMModulePath(@"AzureRM.DataMigration.psd1"),
"AzureRM.Resources.ps1"
);
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
/// <summary>
/// Generate a Resource Management client from the test base to use for managing resource groups.
/// </summary>
/// <returns>Resource Management client</returns>
public static ResourceManagementClient GetResourceClient(DelegatingHandler handler)
{
CSMTestEnvironmentFactory factory = new CSMTestEnvironmentFactory();
return(TestBase.GetServiceClient <ResourceManagementClient>(factory).WithHandler(handler));
}
private void RunPsTestWorkflow(
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName, string tenant)
{
Dictionary <string, string> d = new Dictionary <string, string>();
d.Add("Microsoft.Resources", null);
d.Add("Microsoft.Features", null);
d.Add("Microsoft.Authorization", null);
var providersToIgnore = new Dictionary <string, string>();
providersToIgnore.Add("Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(true, d, providersToIgnore);
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
SetupManagementClients();
helper.SetupEnvironment(AzureModule.AzureResourceManager);
var oldFactory = AzureSession.AuthenticationFactory as MockTokenAuthenticationFactory;
AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(oldFactory.Token.UserId, oldFactory.Token.AccessToken, tenant);
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
helper.SetupModules(AzureModule.AzureResourceManager,
callingClassName + ".ps1",
helper.RMProfileModule);
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment rdfeEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
TestEnvironment csmEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
TestEnvironment currentEnvironment = (mode == AzureModule.AzureResourceManager ? csmEnvironment : rdfeEnvironment);
string jwtToken;
if (mode == AzureModule.AzureResourceManager)
{
jwtToken = csmEnvironment.Credentials != null ?
((TokenCloudCredentials)csmEnvironment.Credentials).Token : null;
}
else if (mode == AzureModule.AzureServiceManagement)
{
jwtToken = rdfeEnvironment.Credentials != null ?
((TokenCloudCredentials)rdfeEnvironment.Credentials).Token : null;
}
else
{
throw new ArgumentException("Invalid module mode.");
}
SetEndpointsToDefaults(rdfeEnvironment, csmEnvironment);
/*
WindowsAzureProfile.Instance.TokenProvider = new FakeAccessTokenProvider(
jwtToken,
csmEnvironment.UserName,
csmEnvironment.AuthorizationContext == null ? null : csmEnvironment.AuthorizationContext.TenatId);
*/
if (HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback)
{
AzureSession.AuthenticationFactory = new MockAuthenticationFactory();
}
else
{
AzureSession.AuthenticationFactory = new MockAuthenticationFactory(currentEnvironment.UserName, jwtToken);
}
AzureEnvironment environment = new AzureEnvironment { Name = testEnvironmentName };
Debug.Assert(currentEnvironment != null);
environment.Endpoints[AzureEnvironment.Endpoint.ActiveDirectory] = currentEnvironment.ActiveDirectoryEndpoint.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Gallery] = currentEnvironment.GalleryUri.AbsoluteUri;
if (csmEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ResourceManager] = csmEnvironment.BaseUri.AbsoluteUri;
}
if (rdfeEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ServiceManagement] = rdfeEnvironment.BaseUri.AbsoluteUri;
}
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
if (!client.Profile.Environments.ContainsKey(testEnvironmentName))
{
client.AddOrSetEnvironment(environment);
}
testSubscription = new AzureSubscription()
{
Id = new Guid(currentEnvironment.SubscriptionId),
Name = testSubscriptionName,
Environment = testEnvironmentName,
Account = currentEnvironment.UserName,
Properties = new Dictionary<AzureSubscription.Property,string>
{
{ AzureSubscription.Property.Default, "True"},
{ AzureSubscription.Property.StorageAccount, Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")},
}
};
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, currentEnvironment.SubscriptionId},
}
};
client.Profile.Subscriptions[testSubscription.Id] = testSubscription;
client.Profile.Accounts[testAccount.Id] = testAccount;
client.SetSubscriptionAsCurrent(testSubscription.Name, testSubscription.Account);
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment currentEnvironment = null;
if (mode == AzureModule.AzureResourceManager)
{
currentEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
}
else
{
currentEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
}
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
SetAuthenticationFactory(mode, currentEnvironment);
AzureEnvironment environment = new AzureEnvironment { Name = testEnvironmentName };
Debug.Assert(currentEnvironment != null);
environment.Endpoints[AzureEnvironment.Endpoint.ActiveDirectory] = currentEnvironment.Endpoints.AADAuthUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Gallery] = currentEnvironment.Endpoints.GalleryUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.ServiceManagement] = currentEnvironment.BaseUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.ResourceManager] = currentEnvironment.Endpoints.ResourceManagementUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Graph] = currentEnvironment.Endpoints.GraphUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.AzureDataLakeAnalyticsCatalogAndJobEndpointSuffix] = currentEnvironment.Endpoints.DataLakeAnalyticsJobAndCatalogServiceUri.OriginalString.Replace("https://", ""); // because it is just a sufix
environment.Endpoints[AzureEnvironment.Endpoint.AzureDataLakeStoreFileSystemEndpointSuffix] = currentEnvironment.Endpoints.DataLakeStoreServiceUri.OriginalString.Replace("https://", ""); // because it is just a sufix
if (!ProfileClient.Profile.Environments.ContainsKey(testEnvironmentName))
{
ProfileClient.AddOrSetEnvironment(environment);
}
if (!AzureRmProfileProvider.Instance.Profile.Environments.ContainsKey(testEnvironmentName))
{
AzureRmProfileProvider.Instance.Profile.Environments[testEnvironmentName] = environment;
}
if (currentEnvironment.SubscriptionId != null)
{
testSubscription = new AzureSubscription()
{
Id = new Guid(currentEnvironment.SubscriptionId),
Name = testSubscriptionName,
Environment = testEnvironmentName,
Account = currentEnvironment.UserName,
Properties = new Dictionary<AzureSubscription.Property, string>
{
{AzureSubscription.Property.Default, "True"},
{
AzureSubscription.Property.StorageAccount,
Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")
},
}
};
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Subscriptions, currentEnvironment.SubscriptionId},
}
};
ProfileClient.Profile.Subscriptions[testSubscription.Id] = testSubscription;
ProfileClient.Profile.Accounts[testAccount.Id] = testAccount;
ProfileClient.SetSubscriptionAsDefault(testSubscription.Name, testSubscription.Account);
var testTenant = new AzureTenant() { Id = Guid.NewGuid() };
if (!string.IsNullOrEmpty(currentEnvironment.Tenant))
{
Guid tenant;
if (Guid.TryParse(currentEnvironment.Tenant, out tenant))
{
testTenant.Id = tenant;
}
}
AzureRmProfileProvider.Instance.Profile.Context = new AzureContext(testSubscription, testAccount, environment, testTenant);
}
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment rdfeEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
TestEnvironment csmEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
TestEnvironment currentEnvironment = (mode == AzureModule.AzureResourceManager ? csmEnvironment : rdfeEnvironment);
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
SetAuthenticationFactory(mode, rdfeEnvironment, csmEnvironment);
AzureEnvironment environment = new AzureEnvironment {
Name = testEnvironmentName
};
Debug.Assert(currentEnvironment != null);
environment.ActiveDirectoryAuthority = currentEnvironment.Endpoints.AADAuthUri.AbsoluteUri;
environment.GalleryUrl = currentEnvironment.Endpoints.GalleryUri.AbsoluteUri;
if (csmEnvironment != null)
{
environment.ResourceManagerUrl = csmEnvironment.BaseUri.AbsoluteUri;
}
if (rdfeEnvironment != null)
{
environment.ServiceManagementUrl = rdfeEnvironment.BaseUri.AbsoluteUri;
}
if (!ProfileClient.Profile.EnvironmentTable.ContainsKey(testEnvironmentName))
{
ProfileClient.AddOrSetEnvironment(environment);
}
if (currentEnvironment.SubscriptionId != null)
{
testSubscription = new AzureSubscription()
{
Id = currentEnvironment.SubscriptionId,
Name = testSubscriptionName,
};
testSubscription.SetEnvironment(testEnvironmentName);
testSubscription.SetAccount(currentEnvironment.UserName);
testSubscription.SetStorageAccount(Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT"));
testSubscription.SetDefault();
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
};
testAccount.SetSubscriptions(currentEnvironment.SubscriptionId);
ProfileClient.Profile.SubscriptionTable[testSubscription.GetId()] = testSubscription;
ProfileClient.Profile.AccountTable[testAccount.Id] = testAccount;
ProfileClient.SetSubscriptionAsDefault(testSubscription.Name, testSubscription.GetAccount());
}
}
/// <summary>
/// Generate an Operational Insights client from the test base to use for managing Operational Insights resources.
/// </summary>
/// <returns>Operational Insights client</returns>
public static OperationalInsightsManagementClient GetOperationalInsightsManagementClient(DelegatingHandler handler)
{
CSMTestEnvironmentFactory factory = new CSMTestEnvironmentFactory();
return TestBase.GetServiceClient<OperationalInsightsManagementClient>(factory).WithHandler(handler);
}
public void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action<CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
Dictionary<string, string> d = new Dictionary<string, string>();
d.Add("Microsoft.Resources", null);
d.Add("Microsoft.Features", null);
d.Add("Microsoft.Authorization", null);
var providersToIgnore = new Dictionary<string, string>();
providersToIgnore.Add("Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(true, d, providersToIgnore);
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
this.helper.SetupEnvironment(AzureModule.AzureResourceManager);
this.SetupManagementClients();
string callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
this.helper.SetupModules(AzureModule.AzureResourceManager,
"ScenarioTests\\Common.ps1",
"ScenarioTests\\" + callingClassName + ".ps1",
helper.RMProfileModule,
helper.RMResourceModule,
helper.GetRMModulePath(@"AzureRM.TrafficManager.psd1"));
try
{
if (scriptBuilder != null)
{
string[] psScripts = scriptBuilder();
if (psScripts != null)
{
this.helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
/// <summary>
/// Generate an Operational Insights client from the test base to use for managing Operational Insights resources.
/// </summary>
/// <returns>Operational Insights client</returns>
public static OperationalInsightsManagementClient GetOperationalInsightsManagementClient(DelegatingHandler handler)
{
CSMTestEnvironmentFactory factory = new CSMTestEnvironmentFactory();
return(TestBase.GetServiceClient <OperationalInsightsManagementClient>(factory).WithHandler(handler));
}
protected GraphRbacManagementClient GetGraphClient()
{
var testFactory = new CSMTestEnvironmentFactory();
var environment = testFactory.GetTestEnvironment();
string tenantId = Guid.Empty.ToString();
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
tenantId = environment.AuthorizationContext.TenantId;
UserDomain = environment.AuthorizationContext.UserDomain;
HttpMockServer.Variables[TenantIdKey] = tenantId;
HttpMockServer.Variables[DomainKey] = UserDomain;
}
else if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
if (HttpMockServer.Variables.ContainsKey(TenantIdKey))
{
tenantId = HttpMockServer.Variables[TenantIdKey];
AzureRmProfileProvider.Instance.Profile.Context.Tenant.Id = new Guid(tenantId);
}
if (HttpMockServer.Variables.ContainsKey(DomainKey))
{
UserDomain = HttpMockServer.Variables[DomainKey];
AzureRmProfileProvider.Instance.Profile.Context.Tenant.Domain = UserDomain;
}
}
return TestBase.GetGraphServiceClient<GraphRbacManagementClient>(testFactory, tenantId);
}
public void RunPsTestWorkflow(
string scenario,
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
var providers = new Dictionary <string, string>();
providers.Add("Microsoft.Resources", null);
providers.Add("Microsoft.Features", null);
providers.Add("Microsoft.Authorization", null);
var providersToIgnore = new Dictionary <string, string>();
providersToIgnore.Add("Microsoft.Azure.Management.Internal.Resources.ResourceManagementClient", "2016-09-01");
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(
true,
providers,
providersToIgnore);
HttpMockServer.RecordsDirectory = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
"SessionRecords");
using (var context = RestTestFramework.MockContext.Start(
callingClassType,
mockName))
{
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize.Invoke(this.csmTestFactory);
}
this.SetupManagementClients(context);
this.helper.SetupEnvironment(AzureModule.AzureResourceManager);
var rmProfileModule = this.helper.RMProfileModule;
this.helper.SetupModules(
AzureModule.AzureResourceManager,
powershellFile,
powershellHelperFile,
rmProfileModule,
this.helper.RMResourceModule,
this.helper.GetRMModulePath("AzureRM.RecoveryServices.psd1"),
this.helper.GetRMModulePath("AzureRM.RecoveryServices.SiteRecovery.psd1"),
"AzureRm.Resources.ps1");
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
this.helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup.Invoke();
}
}
}
}
public static StreamAnalyticsManagementClient GetStreamAnalyticsManagementClient(DelegatingHandler handler)
{
CSMTestEnvironmentFactory factory = new CSMTestEnvironmentFactory();
return(TestBase.GetServiceClient <StreamAnalyticsManagementClient>(factory).WithHandler(handler));
}
protected TestsBase()
{
this.helper = new EnvironmentSetupHelper();
this.csmTestFactory = new CSMTestEnvironmentFactory();
ResourceNamespace = "Microsoft.RecoveryServices";
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment currentEnvironment = null;
if (mode == AzureModule.AzureResourceManager)
{
currentEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
}
else
{
currentEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
}
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
SetAuthenticationFactory(mode, currentEnvironment);
AzureEnvironment environment = new AzureEnvironment {
Name = testEnvironmentName
};
Debug.Assert(currentEnvironment != null);
environment.Endpoints[AzureEnvironment.Endpoint.ActiveDirectory] = currentEnvironment.Endpoints.AADAuthUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Gallery] = currentEnvironment.Endpoints.GalleryUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.ServiceManagement] = currentEnvironment.BaseUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.ResourceManager] = currentEnvironment.Endpoints.ResourceManagementUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Graph] = currentEnvironment.Endpoints.GraphUri.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.AzureDataLakeAnalyticsCatalogAndJobEndpointSuffix] = currentEnvironment.Endpoints.DataLakeAnalyticsJobAndCatalogServiceUri.OriginalString.Replace("https://", ""); // because it is just a sufix
environment.Endpoints[AzureEnvironment.Endpoint.AzureDataLakeStoreFileSystemEndpointSuffix] = currentEnvironment.Endpoints.DataLakeStoreServiceUri.OriginalString.Replace("https://", ""); // because it is just a sufix
if (!ProfileClient.Profile.Environments.ContainsKey(testEnvironmentName))
{
ProfileClient.AddOrSetEnvironment(environment);
}
if (!AzureRmProfileProvider.Instance.Profile.Environments.ContainsKey(testEnvironmentName))
{
AzureRmProfileProvider.Instance.Profile.Environments[testEnvironmentName] = environment;
}
if (currentEnvironment.SubscriptionId != null)
{
testSubscription = new AzureSubscription()
{
Id = new Guid(currentEnvironment.SubscriptionId),
Name = testSubscriptionName,
Environment = testEnvironmentName,
Account = currentEnvironment.UserName,
Properties = new Dictionary <AzureSubscription.Property, string>
{
{ AzureSubscription.Property.Default, "True" },
{
AzureSubscription.Property.StorageAccount,
Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")
},
}
};
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary <AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, currentEnvironment.SubscriptionId },
}
};
ProfileClient.Profile.Subscriptions[testSubscription.Id] = testSubscription;
ProfileClient.Profile.Accounts[testAccount.Id] = testAccount;
ProfileClient.SetSubscriptionAsDefault(testSubscription.Name, testSubscription.Account);
var testTenant = new AzureTenant()
{
Id = Guid.NewGuid()
};
if (!string.IsNullOrEmpty(currentEnvironment.Tenant))
{
Guid tenant;
if (Guid.TryParse(currentEnvironment.Tenant, out tenant))
{
testTenant.Id = tenant;
}
}
AzureRmProfileProvider.Instance.Profile.Context = new AzureContext(testSubscription, testAccount, environment, testTenant);
}
}
protected AzureBackupTestsBase()
{
this.helper = new EnvironmentSetupHelper();
this.csmTestFactory = new CSMTestEnvironmentFactory();
}
public void Initialize(string className)
{
if (initialized)
{
return;
}
HttpMockServer server;
try
{
server = HttpMockServer.CreateInstance();
}
catch (ApplicationException)
{
// mock server has never been initialized, we will need to initialize it.
HttpMockServer.Initialize(className, "InitialCreation");
server = HttpMockServer.CreateInstance();
}
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
fromConfig = FromConfiguration();
if (!fromConfig)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var secret = Guid.NewGuid().ToString();
var mgmtClient = TestBase.GetServiceClient <KeyVaultManagementClient>(testFactory);
var resourcesClient = TestBase.GetServiceClient <ResourceManagementClient>(testFactory);
var tenantId = testEnv.AuthorizationContext.TenatId;
var graphClient = TestBase.GetGraphServiceClient <GraphRbacManagementClient>(testFactory, tenantId);
var appDisplayName = TestUtilities.GenerateName("sdktestapp");
//Setup things in AAD
//Create an application
var app = CreateApplication(graphClient, appDisplayName, secret);
appObjectId = app.Application.ObjectId;
//Create a corresponding service principal
var servicePrincipal = CreateServicePrincipal(app, graphClient);
//Figure out which locations are available for Key Vault
var location = GetKeyVaultLocation(resourcesClient);
//Create a resource group in that location
vaultName = TestUtilities.GenerateName("sdktestvault");
rgName = TestUtilities.GenerateName("sdktestrg");
resourcesClient.ResourceGroups.CreateOrUpdate(rgName, new ResourceGroup {
Location = location
});
//Create a key vault in that resource group
var createResponse = CreateVault(mgmtClient, location, tenantId, servicePrincipal);
vaultAddress = createResponse.Vault.Properties.VaultUri;
_ClientCredential = new ClientCredential(app.Application.AppId, secret);
//Wait a few seconds before trying to authenticate
TestUtilities.Wait(TimeSpan.FromSeconds(30));
}
}
initialized = true;
}
private void SetupAzureEnvironmentFromEnvironmentVariables(AzureModule mode)
{
TestEnvironment rdfeEnvironment = new RDFETestEnvironmentFactory().GetTestEnvironment();
TestEnvironment csmEnvironment = new CSMTestEnvironmentFactory().GetTestEnvironment();
TestEnvironment currentEnvironment = (mode == AzureModule.AzureResourceManager ? csmEnvironment : rdfeEnvironment);
if (currentEnvironment.UserName == null)
{
currentEnvironment.UserName = "******";
}
SetEndpointsToDefaults(rdfeEnvironment, csmEnvironment);
SetAuthenticationFactory(mode, rdfeEnvironment, csmEnvironment);
AzureEnvironment environment = new AzureEnvironment { Name = testEnvironmentName };
Debug.Assert(currentEnvironment != null);
environment.Endpoints[AzureEnvironment.Endpoint.ActiveDirectory] = currentEnvironment.ActiveDirectoryEndpoint.AbsoluteUri;
environment.Endpoints[AzureEnvironment.Endpoint.Gallery] = currentEnvironment.GalleryUri.AbsoluteUri;
if (csmEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ResourceManager] = csmEnvironment.BaseUri.AbsoluteUri;
}
if (rdfeEnvironment != null)
{
environment.Endpoints[AzureEnvironment.Endpoint.ServiceManagement] = rdfeEnvironment.BaseUri.AbsoluteUri;
}
if (!client.Profile.Environments.ContainsKey(testEnvironmentName))
{
client.AddOrSetEnvironment(environment);
}
testSubscription = new AzureSubscription()
{
Id = new Guid(currentEnvironment.SubscriptionId),
Name = testSubscriptionName,
Environment = testEnvironmentName,
Account = currentEnvironment.UserName,
Properties = new Dictionary<AzureSubscription.Property,string>
{
{ AzureSubscription.Property.Default, "True"},
{ AzureSubscription.Property.StorageAccount, Environment.GetEnvironmentVariable("AZURE_STORAGE_ACCOUNT")},
}
};
testAccount = new AzureAccount()
{
Id = currentEnvironment.UserName,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{ AzureAccount.Property.Subscriptions, currentEnvironment.SubscriptionId},
}
};
client.Profile.Subscriptions[testSubscription.Id] = testSubscription;
client.Profile.Accounts[testAccount.Id] = testAccount;
client.SetSubscriptionAsCurrent(testSubscription.Name, testSubscription.Account);
}
public void Dispose()
{
if (HttpMockServer.Mode == HttpRecorderMode.Record && !fromConfig)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var mgmtClient = TestBase.GetServiceClient<KeyVaultManagementClient>(testFactory);
var resourcesClient = TestBase.GetServiceClient<ResourceManagementClient>(testFactory);
var tenantId = testEnv.AuthorizationContext.TenantId;
var graphClient = TestBase.GetGraphServiceClient<GraphRbacManagementClient>(testFactory, tenantId);
mgmtClient.Vaults.Delete(rgName, vaultName);
graphClient.Application.Delete(appObjectId);
resourcesClient.ResourceGroups.Delete(rgName);
}
}
public void RunPsTestWorkflow(
Func <string[]> scriptBuilder,
Action <CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
Dictionary <string, string> d = new Dictionary <string, string>();
d.Add("Microsoft.Authorization", null);
HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(false, d);
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.csmTestFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.csmTestFactory);
}
this.SetupManagementClients();
this.helper.SetupEnvironment(AzureModule.AzureResourceManager);
string callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
this.helper.SetupModules(AzureModule.AzureResourceManager, "ScenarioTests\\Common.ps1", "ScenarioTests\\" + callingClassName + ".ps1",
helper.RMProfileModule,
helper.RMResourceModule,
helper.GetRMModulePath("AzureRM.Dns.psd1"));
try
{
if (scriptBuilder != null)
{
string[] psScripts = scriptBuilder();
if (psScripts != null)
{
this.helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
private void RunPsTestWorkflow(
Func<string[]> scriptBuilder,
Action<CSMTestEnvironmentFactory> initialize,
Action cleanup,
string callingClassType,
string mockName)
{
using (UndoContext context = UndoContext.Current)
{
context.Start(callingClassType, mockName);
this.armTestEnvironmentFactory = new CSMTestEnvironmentFactory();
if (initialize != null)
{
initialize(this.armTestEnvironmentFactory);
}
helper.SetupEnvironment(AzureModule.AzureResourceManager);
SetupManagementClients();
var callingClassName = callingClassType
.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries)
.Last();
List<string> modules = this.SetupCommonModules();
modules.Add(callingClassName + ".ps1");
modules.Add(helper.RMProfileModule);
modules.Add(helper.RMResourceModule);
helper.SetupModules(AzureModule.AzureResourceManager, modules.ToArray());
try
{
if (scriptBuilder != null)
{
var psScripts = scriptBuilder();
if (psScripts != null)
{
helper.RunPowerShellTest(psScripts);
}
}
}
finally
{
if (cleanup != null)
{
cleanup();
}
}
}
}
public void Initialize(string className)
{
if (initialized)
return;
HttpMockServer server;
try
{
server = HttpMockServer.CreateInstance();
}
catch (ApplicationException)
{
// mock server has never been initialized, we will need to initialize it.
HttpMockServer.Initialize(className, "InitialCreation");
server = HttpMockServer.CreateInstance();
}
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
fromConfig = FromConfiguration();
if (!fromConfig)
{
var testFactory = new CSMTestEnvironmentFactory();
var testEnv = testFactory.GetTestEnvironment();
var secret = Guid.NewGuid().ToString();
var mgmtClient = TestBase.GetServiceClient<KeyVaultManagementClient>(testFactory);
var resourcesClient = TestBase.GetServiceClient<ResourceManagementClient>(testFactory);
var tenantId = testEnv.AuthorizationContext.TenantId;
var graphClient = TestBase.GetGraphServiceClient<GraphRbacManagementClient>(testFactory, tenantId);
var appDisplayName = TestUtilities.GenerateName("sdktestapp");
//Setup things in AAD
//Create an application
var app = CreateApplication(graphClient, appDisplayName, secret);
appObjectId = app.Application.ObjectId;
//Create a corresponding service principal
var servicePrincipal = CreateServicePrincipal(app, graphClient);
//Figure out which locations are available for Key Vault
var location = GetKeyVaultLocation(resourcesClient);
//Create a resource group in that location
vaultName = TestUtilities.GenerateName("sdktestvault");
rgName = TestUtilities.GenerateName("sdktestrg");
resourcesClient.ResourceGroups.CreateOrUpdate(rgName, new ResourceGroup {Location = location});
//Create a key vault in that resource group
var createResponse = CreateVault(mgmtClient, location, tenantId, servicePrincipal);
vaultAddress = createResponse.Vault.Properties.VaultUri;
_ClientCredential = new ClientCredential(app.Application.AppId, secret);
//Wait a few seconds before trying to authenticate
TestUtilities.Wait(TimeSpan.FromSeconds(30));
}
}
initialized = true;
}
