/// <summary>
/// Get Batch Context with keys
/// </summary>
public static BatchAccountContext GetBatchAccountContextWithKeys(BatchController controller, string accountName)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
BatchAccountContext context = client.ListKeys(null, accountName);
return context;
}
/// <summary>
/// Creates an account and resource group for use with the Scenario tests
/// </summary>
public static BatchAccountContext CreateTestAccountAndResourceGroup(BatchController controller, string resourceGroupName, string accountName, string location)
{
controller.ResourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup() { Location = location });
BatchAccountCreateResponse createResponse = controller.BatchManagementClient.Accounts.Create(resourceGroupName, accountName, new BatchAccountCreateParameters() { Location = location });
BatchAccountContext context = BatchAccountContext.ConvertAccountResourceToNewAccountContext(createResponse.Resource);
BatchAccountListKeyResponse response = controller.BatchManagementClient.Accounts.ListKeys(resourceGroupName, accountName);
context.PrimaryAccountKey = response.PrimaryKey;
context.SecondaryAccountKey = response.SecondaryKey;
return context;
}
public void TestChangeOSVersion()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string poolId = "changeospool";
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-ChangeOSVersion '{0}' '{1}'", poolId, specificOSVersion) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.CreateTestPool(controller, context, poolId, targetDedicated: 0, targetLowPriority: 0);
},
() =>
{
ScenarioTestHelpers.DeletePool(controller, context, poolId);
},
MethodBase.GetCurrentMethod().ReflectedType?.ToString(),
MethodBase.GetCurrentMethod().Name);
}
/// <summary>
/// Creates a test pool for use in Scenario tests.
/// </summary>
public static void CreateTestPool(BatchController controller, BatchAccountContext context, string poolId, int targetDedicated, CertificateReference certReference = null)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
PSCertificateReference[] certReferences = null;
if (certReference != null)
{
certReferences = new PSCertificateReference[] { new PSCertificateReference(certReference) };
}
NewPoolParameters parameters = new NewPoolParameters(context, poolId)
{
VirtualMachineSize = "small",
OSFamily = "4",
TargetOSVersion = "*",
TargetDedicated = targetDedicated,
CertificateReferences = certReferences,
};
client.CreatePool(parameters);
}
public void IfJobSetsAutoFailure_ItCompletesWhenAnyTaskFails()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string jobId = "testJobCompletesWhenTaskFails";
string taskId = "taskId-1";
PSCloudJob completedJob = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("IfJobSetsAutoFailure-ItCompletesWhenAnyTaskFails '{0}' '{1}'", jobId, taskId) }); },
null,
() =>
{
context = new ScenarioTestContext();
completedJob = ScenarioTestHelpers.WaitForJobCompletion(controller, context, jobId, taskId);
AssertJobIsCompleteDueToTaskFailure(completedJob);
ScenarioTestHelpers.DeleteJob(controller, context, jobId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
/// <summary>
/// Waits for the specified task to complete
/// </summary>
public static void WaitForTaskCompletion(BatchController controller, BatchAccountContext context, string workItemName, string jobName, string taskName)
{
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListTaskOptions options = new ListTaskOptions()
{
Context = context,
WorkItemName = workItemName,
JobName = jobName,
TaskName = taskName,
AdditionalBehaviors = behaviors
};
IEnumerable <PSCloudTask> tasks = client.ListTasks(options);
ITaskStateMonitor monitor = context.BatchOMClient.OpenToolbox().CreateTaskStateMonitor();
monitor.WaitAll(tasks.Select(t => t.omObject), TaskState.Completed, TimeSpan.FromMinutes(2), null, behaviors);
}
public void TestGetCertificateByThumbprint()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string thumbprintAlgorithm = null;
string thumbprint = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-GetCertificateByThumbprint '{0}' '{1}' '{2}'", accountName, BatchTestHelpers.TestCertificateAlgorithm, thumbprint) }); },
() =>
{
context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName);
thumbprint = ScenarioTestHelpers.AddTestCertificate(controller, context, BatchTestHelpers.TestCertificateFileName1);
},
() =>
{
ScenarioTestHelpers.DeleteTestCertificate(controller, context, BatchTestHelpers.TestCertificateAlgorithm, thumbprint);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestGetJobRequiredParameters()
{
BatchController controller = BatchController.NewInstance;
string resourceGroupName = "test-get-job-params";
string accountName = "testgetjobparams";
string location = "eastus";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-GetJobRequiredParameters '{0}'", accountName) }); },
() =>
{
context = ScenarioTestHelpers.CreateTestAccountAndResourceGroup(controller, resourceGroupName, accountName, location);
},
() =>
{
ScenarioTestHelpers.CleanupTestAccount(controller, resourceGroupName, accountName);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestRemoveComputeNodes()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string removeNodePoolId = "removenodepool";
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-RemoveComputeNodes '{0}'", removeNodePoolId) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.CreateTestPool(controller, context, removeNodePoolId, targetDedicated: 2, targetLowPriority: 0);
ScenarioTestHelpers.WaitForSteadyPoolAllocation(controller, context, removeNodePoolId);
},
() =>
{
ScenarioTestHelpers.DeletePool(controller, context, removeNodePoolId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestDisableAndEnableJobSchedule()
{
BatchController controller = BatchController.NewInstance;
string jobScheduleId = "testDisableEnableJobSchedule";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-DisableAndEnableJobSchedule '{0}' '1'", jobScheduleId) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.CreateTestJobSchedule(controller, context, jobScheduleId, null);
},
() =>
{
ScenarioTestHelpers.DeleteJobSchedule(controller, context, jobScheduleId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
/// <summary>
/// Creates a test task for use in Scenario tests.
/// </summary>
public static void CreateTestTask(BatchController controller, BatchAccountContext context, string jobId, string taskId, string cmdLine = "cmd /c dir /s", int numInstances = 0)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
PSMultiInstanceSettings multiInstanceSettings = null;
if (numInstances > 1)
{
multiInstanceSettings = new PSMultiInstanceSettings(numInstances);
multiInstanceSettings.CoordinationCommandLine = "cmd /c echo coordinating";
}
NewTaskParameters parameters = new NewTaskParameters(context, jobId, null, taskId)
{
CommandLine = cmdLine,
MultiInstanceSettings = multiInstanceSettings,
RunElevated = numInstances <= 1
};
client.CreateTask(parameters);
}
public void TestEnableAutoScaleByPipeline()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-EnableAutoScale '{0}' '1'", testPoolId) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.WaitForSteadyPoolAllocation(controller, context, testPoolId);
ScenarioTestHelpers.DisableAutoScale(controller, context, testPoolId);
ScenarioTestHelpers.WaitForSteadyPoolAllocation(controller, context, testPoolId);
},
() =>
{
ScenarioTestHelpers.DisableAutoScale(controller, context, testPoolId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestUpdatePool()
{
BatchController controller = BatchController.NewInstance;
string poolId = "testUpdate";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-UpdatePool '{0}' '{1}'", commonAccountName, poolId) }); },
() =>
{
context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, commonAccountName);
ScenarioTestHelpers.CreateTestPool(controller, context, poolId, 0);
},
() =>
{
ScenarioTestHelpers.DeletePool(controller, context, poolId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestCreateTaskCollection()
{
BatchController controller = BatchController.NewInstance;
string jobId = "createTaskCollectionJob";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
_logger,
() => { return(new string[] { string.Format("Test-CreateTaskCollection '{0}'", jobId) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.CreateTestJob(controller, context, jobId);
},
() =>
{
ScenarioTestHelpers.DeleteJob(controller, context, jobId);
},
MethodBase.GetCurrentMethod().ReflectedType?.ToString(),
MethodBase.GetCurrentMethod().Name);
}
public void TestDisableEnableTerminateJobSchedule()
{
BatchController controller = BatchController.NewInstance;
string jobScheduleId = "testDisableEnableTerminateJobSchedule";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-DisableEnableTerminateJobSchedule '{0}'", jobScheduleId) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.CreateTestJobSchedule(controller, context, jobScheduleId, null);
},
() =>
{
ScenarioTestHelpers.DeleteJobSchedule(controller, context, jobScheduleId);
},
MethodBase.GetCurrentMethod().ReflectedType?.ToString(),
MethodBase.GetCurrentMethod().Name);
}
public void TestRebootAndReimageComputeNode()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string computeNodeId = null;
string computeNodeId2 = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-RebootAndReimageComputeNode '{0}' '{1}' '{2}'", poolId, computeNodeId, computeNodeId2) }); },
() =>
{
context = new ScenarioTestContext();
computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 0);
computeNodeId2 = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 1);
ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId);
ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId2);
},
null,
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestAutoScaleActions()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string poolId = "autoscalePool";
controller.RunPsTestWorkflow(
_logger,
() => { return(new string[] { string.Format("Test-AutoScaleActions '{0}'", poolId) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.CreateTestPool(controller, context, poolId, targetDedicated: 0, targetLowPriority: 0);
},
() =>
{
ScenarioTestHelpers.DeletePool(controller, context, poolId);
},
MethodBase.GetCurrentMethod().ReflectedType?.ToString(),
MethodBase.GetCurrentMethod().Name);
}
public void TestListTaskPipeline()
{
BatchController controller = BatchController.NewInstance;
string jobId = "listTaskPipeJob";
string taskId = "testTask";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-ListTaskPipeline '{0}' '{1}'", jobId, taskId) }); },
() =>
{
context = new ScenarioTestContext();
ScenarioTestHelpers.CreateTestJob(controller, context, jobId);
ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId);
},
() =>
{
ScenarioTestHelpers.DeleteJob(controller, context, jobId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestUpdateComputeNodeUser()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string computeNodeId = null;
string userName = "******";
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-UpdateComputeNodeUser '{0}' '{1}' '{2}'", poolId, computeNodeId, userName) }); },
() =>
{
context = new ScenarioTestContext();
computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId);
ScenarioTestHelpers.CreateComputeNodeUser(controller, context, poolId, computeNodeId, userName);
},
() =>
{
ScenarioTestHelpers.DeleteComputeNodeUser(controller, context, poolId, computeNodeId, userName);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void TestGetTaskById()
{
BatchController controller = BatchController.NewInstance;
string jobId = "getTaskJob";
string taskId = "testTask";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-GetTaskById '{0}' '{1}' '{2}'", accountName, jobId, taskId) }); },
() =>
{
context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName);
ScenarioTestHelpers.CreateTestJob(controller, context, jobId);
ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId);
},
() =>
{
ScenarioTestHelpers.DeleteJob(controller, context, jobId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
/// <summary>
/// Uploads an application package to Storage
/// </summary>
public static ApplicationPackage CreateApplicationPackage(BatchController controller, BatchAccountContext context, string applicationName, string version, string filePath)
{
ApplicationPackage applicationPackage = null;
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
applicationPackage = controller.BatchManagementClient.ApplicationPackage.Create(
context.ResourceGroupName,
context.AccountName,
applicationName,
version);
CloudBlockBlob blob = new CloudBlockBlob(new Uri(applicationPackage.StorageUrl));
#if NETSTANDARD
Task.Run(() => blob.UploadFromFileAsync(filePath)).Wait();
#else
blob.UploadFromFile(filePath, FileMode.Open);
#endif
}
return(applicationPackage);
}
public static void WaitForSteadyPoolAllocation(BatchController controller, BatchAccountContext context, string poolId)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListPoolOptions options = new ListPoolOptions(context)
{
PoolId = poolId
};
DateTime timeout = DateTime.Now.AddMinutes(5);
PSCloudPool pool = client.ListPools(options).First();
while (pool.AllocationState != AllocationState.Steady)
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for steady allocation state");
}
Sleep(5000);
pool = client.ListPools(options).First();
}
}
public void TestRebootAndReimageComputeNode()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string computeNodeId = null;
string computeNodeId2 = null;
controller.RunPsTestWorkflow(
_logger,
() => { return(new string[] { string.Format("Test-RebootAndReimageComputeNode '{0}' '{1}' '{2}'", poolId, computeNodeId, computeNodeId2) }); },
() =>
{
context = new ScenarioTestContext();
computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 0);
computeNodeId2 = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 1);
ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId);
ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId2);
},
null,
MethodBase.GetCurrentMethod().ReflectedType?.ToString(),
MethodBase.GetCurrentMethod().Name);
}
public void TestGetJobByName()
{
BatchController controller = BatchController.NewInstance;
string workItemName = "testName";
string jobName = null;
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-GetJobByName '{0}' '{1}' '{2}'", accountName, workItemName, jobName) }); },
() =>
{
context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName);
ScenarioTestHelpers.CreateTestWorkItem(controller, context, workItemName);
jobName = ScenarioTestHelpers.WaitForRecentJob(controller, context, workItemName);
},
() =>
{
ScenarioTestHelpers.DeleteWorkItem(controller, context, workItemName);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
public void IfJobSetsAutoFailure_ItCompletesWhenAnyTaskFails()
{
BatchController controller = BatchController.NewInstance;
BatchAccountContext context = null;
string poolId = "testPool";
string jobId = "testJobCompletesWhenTaskFails";
string taskId = "taskId-1";
PSCloudJob completedJob = null;
controller.RunPsTestWorkflow(
_logger,
() => { return(new string[] { string.Format("IfJobSetsAutoFailure-ItCompletesWhenAnyTaskFails '{0}' '{1}' '{2}'", poolId, jobId, taskId) }); },
null,
() =>
{
context = new ScenarioTestContext();
completedJob = ScenarioTestHelpers.WaitForJobCompletion(controller, context, jobId, taskId);
AssertJobIsCompleteDueToTaskFailure(completedJob);
ScenarioTestHelpers.DeleteJob(controller, context, jobId);
},
MethodBase.GetCurrentMethod().ReflectedType?.ToString(),
MethodBase.GetCurrentMethod().Name);
}
/// <summary>
/// Waits for a compute node to get to the idle state
/// </summary>
public static void WaitForIdleComputeNode(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListComputeNodeOptions options = new ListComputeNodeOptions(context, poolId, null)
{
ComputeNodeId = computeNodeId
};
DateTime timeout = DateTime.Now.AddMinutes(2);
PSComputeNode computeNode = client.ListComputeNodes(options).First();
if (computeNode.State != ComputeNodeState.Idle)
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for idle compute node");
}
Sleep(5000);
computeNode = client.ListComputeNodes(options).First();
}
}
/// <summary>
/// Waits for a recent job on a job schedule and returns its id. If a previous job is specified, this method waits until a new job is created.
/// </summary>
public static string WaitForRecentJob(BatchController controller, BatchAccountContext context, string jobScheduleId, string previousJob = null)
{
DateTime timeout = DateTime.Now.AddMinutes(2);
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListJobScheduleOptions options = new ListJobScheduleOptions(context)
{
JobScheduleId = jobScheduleId,
Filter = null,
MaxCount = Constants.DefaultMaxCount
};
PSCloudJobSchedule jobSchedule = client.ListJobSchedules(options).First();
while (jobSchedule.ExecutionInformation.RecentJob == null || string.Equals(jobSchedule.ExecutionInformation.RecentJob.Id, previousJob, StringComparison.OrdinalIgnoreCase))
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for recent job");
}
Sleep(5000);
jobSchedule = client.ListJobSchedules(options).First();
}
return(jobSchedule.ExecutionInformation.RecentJob.Id);
}
/// <summary>
/// Creates a test job schedule for use in Scenario tests.
/// </summary>
public static void CreateTestJobSchedule(BatchController controller, BatchAccountContext context, string jobScheduleId, TimeSpan?recurrenceInterval)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
PSJobSpecification jobSpecification = new PSJobSpecification();
jobSpecification.PoolInformation = new PSPoolInformation();
jobSpecification.PoolInformation.PoolId = SharedPool;
PSSchedule schedule = new PSSchedule();
if (recurrenceInterval != null)
{
schedule = new PSSchedule();
schedule.RecurrenceInterval = recurrenceInterval;
}
NewJobScheduleParameters parameters = new NewJobScheduleParameters(context, jobScheduleId)
{
JobSpecification = jobSpecification,
Schedule = schedule
};
client.CreateJobSchedule(parameters);
}
public static string WaitForOSVersionChange(BatchController controller, BatchAccountContext context, string poolId)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListPoolOptions options = new ListPoolOptions(context)
{
PoolId = poolId
};
DateTime timeout = DateTime.Now.AddMinutes(5);
PSCloudPool pool = client.ListPools(options).First();
while (pool.CloudServiceConfiguration.CurrentOSVersion != pool.CloudServiceConfiguration.TargetOSVersion)
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for active state pool");
}
Sleep(5000);
pool = client.ListPools(options).First();
}
return(pool.CloudServiceConfiguration.TargetOSVersion);
}
/// <summary>
/// Deletes a certificate.
/// </summary>
public static void WaitForCertificateToFailDeletion(BatchController controller, BatchAccountContext context, string thumbprintAlgorithm, string thumbprint)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListCertificateOptions parameters = new ListCertificateOptions(context)
{
ThumbprintAlgorithm = BatchTestHelpers.TestCertificateAlgorithm,
Thumbprint = thumbprint
};
PSCertificate cert = client.ListCertificates(parameters).First();
DateTime timeout = DateTime.Now.AddMinutes(2);
while (cert.State != CertificateState.DeleteFailed)
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for failed certificate deletion");
}
Sleep(10000);
cert = client.ListCertificates(parameters).First();
}
}
/// <summary>
/// Creates a test pool for use in Scenario tests.
/// </summary>
public static void CreateTestPool(
BatchController controller,
BatchAccountContext context,
string poolId,
int?targetDedicated,
int?targetLowPriority,
CertificateReference certReference = null,
StartTask startTask = null)
{
PSCertificateReference[] certReferences = null;
if (certReference != null)
{
certReferences = new PSCertificateReference[] { new PSCertificateReference(certReference) };
}
PSStartTask psStartTask = null;
if (startTask != null)
{
psStartTask = new PSStartTask(startTask);
}
PSCloudServiceConfiguration paasConfiguration = new PSCloudServiceConfiguration("4", "*");
NewPoolParameters parameters = new NewPoolParameters(context, poolId)
{
VirtualMachineSize = "small",
CloudServiceConfiguration = paasConfiguration,
TargetDedicatedComputeNodes = targetDedicated,
TargetLowPriorityComputeNodes = targetLowPriority,
CertificateReferences = certReferences,
StartTask = psStartTask,
InterComputeNodeCommunicationEnabled = true
};
CreatePoolIfNotExists(controller, parameters);
}
public void TestUpdateTask()
{
BatchController controller = BatchController.NewInstance;
string jobId = "updateTaskJob";
string taskId = "testTask";
BatchAccountContext context = null;
controller.RunPsTestWorkflow(
() => { return(new string[] { string.Format("Test-UpdateTask '{0}' '{1}' '{2}'", accountName, jobId, taskId) }); },
() =>
{
context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName);
ScenarioTestHelpers.CreateTestJob(controller, context, jobId);
// Make the task long running so the constraints can be updated
ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId, "ping -t localhost -w 60");
},
() =>
{
ScenarioTestHelpers.DeleteJob(controller, context, jobId);
},
TestUtilities.GetCallingClass(),
TestUtilities.GetCurrentMethodName());
}
/// <summary>
/// Gets the CurrentDedicated count from a pool
/// </summary>
public static int GetPoolCurrentDedicated(BatchController controller, BatchAccountContext context, string poolId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListPoolOptions options = new ListPoolOptions(context, behaviors)
{
PoolId = poolId
};
PSCloudPool pool = client.ListPools(options).First();
return pool.CurrentDedicated.Value;
}
public static void WaitForSteadyPoolAllocation(BatchController controller, BatchAccountContext context, string poolId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListPoolOptions options = new ListPoolOptions(context, behaviors)
{
PoolId = poolId
};
DateTime timeout = DateTime.Now.AddMinutes(2);
PSCloudPool pool = client.ListPools(options).First();
while (pool.AllocationState != AllocationState.Steady)
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for steady allocation state");
}
Sleep(5000);
pool = client.ListPools(options).First();
}
}
/// <summary>
/// Waits for a recent job on a workitem and returns its name. If a previous job is specified, this method waits until a new job is created.
/// </summary>
public static string WaitForRecentJob(BatchController controller, BatchAccountContext context, string workItemName, string previousJob = null)
{
DateTime timeout = DateTime.Now.AddMinutes(2);
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListWorkItemOptions options = new ListWorkItemOptions(context, behaviors)
{
WorkItemName = workItemName,
Filter = null,
MaxCount = Constants.DefaultMaxCount
};
PSCloudWorkItem workItem = client.ListWorkItems(options).First();
while (workItem.ExecutionInformation.RecentJob == null || string.Equals(workItem.ExecutionInformation.RecentJob.Name, previousJob, StringComparison.OrdinalIgnoreCase))
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for recent job");
}
Sleep(5000);
workItem = client.ListWorkItems(options).First();
}
return workItem.ExecutionInformation.RecentJob.Name;
}
/// <summary>
/// Waits for a compute node to get to the idle state
/// </summary>
public static void WaitForIdleComputeNode(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListComputeNodeOptions options = new ListComputeNodeOptions(context, poolId, null, behaviors)
{
ComputeNodeId = computeNodeId
};
DateTime timeout = DateTime.Now.AddMinutes(2);
PSComputeNode computeNode = client.ListComputeNodes(options).First();
if (computeNode.State != ComputeNodeState.Idle)
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for idle compute node");
}
Sleep(5000);
computeNode = client.ListComputeNodes(options).First();
}
}
/// <summary>
/// Deletes a job used in a Scenario test.
/// </summary>
public static void DeleteJob(BatchController controller, BatchAccountContext context, string jobId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
client.DeleteJob(context, jobId, behaviors);
}
/// <summary>
/// Creates a test user for use in Scenario tests.
/// </summary>
public static void CreateTestUser(BatchController controller, BatchAccountContext context, string poolName, string vmName, string vmUserName)
{
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
NewVMUserParameters parameters = new NewVMUserParameters(context, poolName, vmName, null, behaviors)
{
VMUserName = vmUserName,
Password = "******",
};
client.CreateVMUser(parameters);
}
/// <summary>
/// Creates a test job for use in Scenario tests.
/// </summary>
public static void CreateTestJob(BatchController controller, BatchAccountContext context, string jobId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
PSPoolInformation poolInfo = new PSPoolInformation();
poolInfo.PoolId = SharedPool;
NewJobParameters parameters = new NewJobParameters(context, jobId, behaviors)
{
PoolInformation = poolInfo
};
client.CreateJob(parameters);
}
/// <summary>
/// Waits for the specified task to complete
/// </summary>
public static void WaitForTaskCompletion(BatchController controller, BatchAccountContext context, string workItemName, string jobName, string taskName)
{
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListTaskOptions options = new ListTaskOptions(context, workItemName, jobName, null, behaviors)
{
TaskName = taskName
};
IEnumerable<PSCloudTask> tasks = client.ListTasks(options);
ITaskStateMonitor monitor = context.BatchOMClient.OpenToolbox().CreateTaskStateMonitor();
monitor.WaitAll(tasks.Select(t => t.omObject), TaskState.Completed, TimeSpan.FromMinutes(2), null, behaviors);
}
/// <summary>
/// Adds a test certificate for use in Scenario tests. Returns the thumbprint of the cert.
/// </summary>
public static string AddTestCertificate(BatchController controller, BatchAccountContext context, string filePath)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
X509Certificate2 cert = new X509Certificate2(filePath);
ListCertificateOptions getParameters = new ListCertificateOptions(context)
{
ThumbprintAlgorithm = BatchTestHelpers.TestCertificateAlgorithm,
Thumbprint = cert.Thumbprint,
Select = "thumbprint,state"
};
try
{
PSCertificate existingCert = client.ListCertificates(getParameters).FirstOrDefault();
DateTime start = DateTime.Now;
DateTime end = start.AddMinutes(5);
// Cert might still be deleting from other tests, so we wait for the delete to finish.
while (existingCert != null && existingCert.State == CertificateState.Deleting)
{
if (DateTime.Now > end)
{
throw new TimeoutException("Timed out waiting for existing cert to be deleted.");
}
Sleep(5000);
existingCert = client.ListCertificates(getParameters).FirstOrDefault();
}
}
catch (AggregateException ex)
{
foreach (Exception inner in ex.InnerExceptions)
{
BatchException batchEx = inner as BatchException;
// When the cert doesn't exist, we get a 404 error. For all other errors, throw.
if (batchEx == null || !batchEx.Message.Contains("CertificateNotFound"))
{
throw;
}
}
}
NewCertificateParameters parameters = new NewCertificateParameters(context, null, cert.RawData);
client.AddCertificate(parameters);
return cert.Thumbprint;
}
/// <summary>
/// Deletes a workitem used in a Scenario test.
/// </summary>
public static void DeleteWorkItem(BatchController controller, BatchAccountContext context, string workItemName)
{
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
client.DeleteWorkItem(context, workItemName, behaviors);
}
/// <summary>
/// Gets the number of pools under the specified account
/// </summary>
public static int GetPoolCount(BatchController controller, BatchAccountContext context)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListPoolOptions options = new ListPoolOptions(context, behaviors);
return client.ListPools(options).Count();
}
/// <summary>
/// Creates a test task for use in Scenario tests.
/// </summary>
public static void CreateTestTask(BatchController controller, BatchAccountContext context, string jobId, string taskId, string cmdLine = "cmd /c dir /s")
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
NewTaskParameters parameters = new NewTaskParameters(context, jobId, null, taskId, behaviors)
{
CommandLine = cmdLine,
RunElevated = true
};
client.CreateTask(parameters);
}
/// <summary>
/// Creates a test job schedule for use in Scenario tests.
/// </summary>
public static void CreateTestJobSchedule(BatchController controller, BatchAccountContext context, string jobScheduleId, TimeSpan? recurrenceInterval)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
PSJobSpecification jobSpecification = new PSJobSpecification();
jobSpecification.PoolInformation = new PSPoolInformation();
jobSpecification.PoolInformation.PoolId = SharedPool;
PSSchedule schedule = new PSSchedule();
if (recurrenceInterval != null)
{
schedule = new PSSchedule();
schedule.RecurrenceInterval = recurrenceInterval;
}
NewJobScheduleParameters parameters = new NewJobScheduleParameters(context, jobScheduleId, behaviors)
{
JobSpecification = jobSpecification,
Schedule = schedule
};
client.CreateJobSchedule(parameters);
}
/// <summary>
/// Deletes a user used in a Scenario test.
/// </summary>
public static void DeleteUser(BatchController controller, BatchAccountContext context, string poolName, string vmName, string vmUserName)
{
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
VMUserOperationParameters parameters = new VMUserOperationParameters(context, poolName, vmName, vmUserName, behaviors);
client.DeleteVMUser(parameters);
}
/// <summary>
/// Waits for a recent job on a job schedule and returns its id. If a previous job is specified, this method waits until a new job is created.
/// </summary>
public static string WaitForRecentJob(BatchController controller, BatchAccountContext context, string jobScheduleId, string previousJob = null)
{
DateTime timeout = DateTime.Now.AddMinutes(2);
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListJobScheduleOptions options = new ListJobScheduleOptions(context, behaviors)
{
JobScheduleId = jobScheduleId,
Filter = null,
MaxCount = Constants.DefaultMaxCount
};
PSCloudJobSchedule jobSchedule = client.ListJobSchedules(options).First();
while (jobSchedule.ExecutionInformation.RecentJob == null || string.Equals(jobSchedule.ExecutionInformation.RecentJob.Id, previousJob, StringComparison.OrdinalIgnoreCase))
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for recent job");
}
Sleep(5000);
jobSchedule = client.ListJobSchedules(options).First();
}
return jobSchedule.ExecutionInformation.RecentJob.Id;
}
/// <summary>
/// Cleans up an account and resource group used in a Scenario test.
/// </summary>
public static void CleanupTestAccount(BatchController controller, string resourceGroupName, string accountName)
{
controller.BatchManagementClient.Accounts.Delete(resourceGroupName, accountName);
controller.ResourceManagementClient.ResourceGroups.Delete(resourceGroupName);
}
/// <summary>
/// Waits for the specified task to complete
/// </summary>
public static void WaitForTaskCompletion(BatchController controller, BatchAccountContext context, string jobId, string taskId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListTaskOptions options = new ListTaskOptions(context, jobId, null, behaviors)
{
TaskId = taskId
};
IEnumerable<PSCloudTask> tasks = client.ListTasks(options);
// Save time by not waiting during playback scenarios
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
TaskStateMonitor monitor = context.BatchOMClient.Utilities.CreateTaskStateMonitor();
monitor.WaitAll(tasks.Select(t => t.omObject), TaskState.Completed, TimeSpan.FromMinutes(2), null);
}
}
/// <summary>
/// Creates a compute node user for use in Scenario tests.
/// </summary>
public static void CreateComputeNodeUser(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId, string computeNodeUserName)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
NewComputeNodeUserParameters parameters = new NewComputeNodeUserParameters(context, poolId, computeNodeId, null)
{
ComputeNodeUserName = computeNodeUserName,
Password = "******",
};
client.CreateComputeNodeUser(parameters);
}
/// <summary>
/// Gets the id of a compute node in the specified pool
/// </summary>
public static string GetComputeNodeId(BatchController controller, BatchAccountContext context, string poolId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListComputeNodeOptions options = new ListComputeNodeOptions(context, poolId, null, behaviors);
return client.ListComputeNodes(options).First().Id;
}
/// <summary>
/// Creates a test workitem for use in Scenario tests.
/// </summary>
public static void CreateTestWorkItem(BatchController controller, BatchAccountContext context, string workItemName)
{
CreateTestWorkItem(controller, context, workItemName, null);
}
/// <summary>
/// Creates a test user for use in Scenario tests.
/// </summary>
public static void CreateComputeNodeUser(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId, string computeNodeUserName)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
NewComputeNodeUserParameters parameters = new NewComputeNodeUserParameters(context, poolId, computeNodeId, null, behaviors)
{
ComputeNodeUserName = computeNodeUserName,
Password = "******",
};
client.CreateComputeNodeUser(parameters);
}
public static void DisableAutoScale(BatchController controller, BatchAccountContext context, string poolId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
PoolOperationParameters parameters = new PoolOperationParameters(context, poolId, null, behaviors);
client.DisableAutoScale(parameters);
}
public static string WaitForOSVersionChange(BatchController controller, BatchAccountContext context, string poolId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ListPoolOptions options = new ListPoolOptions(context, behaviors)
{
PoolId = poolId
};
DateTime timeout = DateTime.Now.AddMinutes(2);
PSCloudPool pool = client.ListPools(options).First();
while (pool.CurrentOSVersion != pool.TargetOSVersion)
{
if (DateTime.Now > timeout)
{
throw new TimeoutException("Timed out waiting for active state pool");
}
Sleep(5000);
pool = client.ListPools(options).First();
}
return pool.TargetOSVersion;
}
/// <summary>
/// Creates a test pool for use in Scenario tests.
/// </summary>
public static void CreateTestPool(BatchController controller, BatchAccountContext context, string poolName)
{
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
NewPoolParameters parameters = new NewPoolParameters(context, poolName, behaviors)
{
OSFamily = "4",
TargetOSVersion = "*",
TargetDedicated = 1
};
client.CreatePool(parameters);
}
/// <summary>
/// Creates a test pool for use in Scenario tests.
/// </summary>
public static void CreateTestPool(BatchController controller, BatchAccountContext context, string poolId, int targetDedicated)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
NewPoolParameters parameters = new NewPoolParameters(context, poolId, behaviors)
{
VirtualMachineSize = "small",
OSFamily = "4",
TargetOSVersion = "*",
TargetDedicated = targetDedicated,
};
client.CreatePool(parameters);
}
/// <summary>
/// Deletes a compute node user for use in Scenario tests.
/// </summary>
public static void DeleteComputeNodeUser(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId, string computeNodeUserName)
{
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
ComputeNodeUserOperationParameters parameters = new ComputeNodeUserOperationParameters(context, poolId, computeNodeId, computeNodeUserName);
client.DeleteComputeNodeUser(parameters);
}
public static void EnableAutoScale(BatchController controller, BatchAccountContext context, string poolId)
{
RequestInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
string formula = "$TargetDedicated=2";
AutoScaleParameters parameters = new AutoScaleParameters(context, poolId, null, formula, behaviors);
client.EnableAutoScale(parameters);
}
/// <summary>
/// Creates a test workitem for use in Scenario tests.
/// </summary>
public static void CreateTestWorkItem(BatchController controller, BatchAccountContext context, string workItemName, TimeSpan? recurrenceInterval)
{
YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
PSJobExecutionEnvironment jobExecutionEnvironment = new PSJobExecutionEnvironment();
jobExecutionEnvironment.PoolName = DefaultPoolName;
PSWorkItemSchedule schedule = null;
if (recurrenceInterval != null)
{
schedule = new PSWorkItemSchedule();
schedule.RecurrenceInterval = recurrenceInterval;
}
NewWorkItemParameters parameters = new NewWorkItemParameters(context, workItemName, behaviors)
{
JobExecutionEnvironment = jobExecutionEnvironment,
Schedule = schedule
};
client.CreateWorkItem(parameters);
}