public void NewBatchTaskParametersGetPassedToRequestTest(string commandline)
{
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
cmdlet.Id = "testTask";
cmdlet.JobId = "testJob";
cmdlet.AffinityInformation = new PSAffinityInformation("affinityValue");
cmdlet.DisplayName = "display name";
cmdlet.Constraints = new PSTaskConstraints(TimeSpan.FromHours(1), TimeSpan.FromDays(2), 5);
cmdlet.CommandLine = commandline;
cmdlet.EnvironmentSettings = new Dictionary <string, string>();
cmdlet.EnvironmentSettings.Add("env1", "value1");
cmdlet.MultiInstanceSettings = new PSMultiInstanceSettings("cmd /c echo coordinating", 3)
{
CommonResourceFiles = new List <PSResourceFile>()
{
new PSResourceFile(ResourceFile.FromUrl("https://some.blob", "myFile.txt"))
}
};
cmdlet.ResourceFiles = new PSResourceFile[]
{
new PSResourceFile(ResourceFile.FromUrl("anotherFile.txt", "https://another.blob"))
};
TaskAddParameter requestParameters = null;
// Store the request parameters
RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor <
TaskAddParameter,
TaskAddOptions,
AzureOperationHeaderResponse <TaskAddHeaders> >(requestAction: (r) =>
{
requestParameters = r.Parameters;
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
cmdlet.ExecuteCmdlet();
// Verify the request parameters match the cmdlet parameters
Assert.Equal(cmdlet.AffinityInformation.AffinityId, requestParameters.AffinityInfo.AffinityId);
Assert.Equal(cmdlet.DisplayName, requestParameters.DisplayName);
Assert.Equal(cmdlet.Constraints.RetentionTime, requestParameters.Constraints.RetentionTime);
Assert.Equal(cmdlet.Constraints.MaxTaskRetryCount, requestParameters.Constraints.MaxTaskRetryCount);
Assert.Equal(cmdlet.Constraints.MaxWallClockTime, requestParameters.Constraints.MaxWallClockTime);
Assert.Equal(cmdlet.CommandLine, requestParameters.CommandLine);
Assert.Equal(cmdlet.EnvironmentSettings.Count, requestParameters.EnvironmentSettings.Count);
Assert.Equal(cmdlet.EnvironmentSettings["env1"], requestParameters.EnvironmentSettings[0].Value);
Assert.Equal(cmdlet.MultiInstanceSettings.NumberOfInstances, requestParameters.MultiInstanceSettings.NumberOfInstances);
Assert.Equal(cmdlet.MultiInstanceSettings.CoordinationCommandLine, requestParameters.MultiInstanceSettings.CoordinationCommandLine);
Assert.Equal(cmdlet.MultiInstanceSettings.CommonResourceFiles.Count, requestParameters.MultiInstanceSettings.CommonResourceFiles.Count);
Assert.Equal(cmdlet.MultiInstanceSettings.CommonResourceFiles[0].HttpUrl, requestParameters.MultiInstanceSettings.CommonResourceFiles[0].HttpUrl);
Assert.Equal(cmdlet.MultiInstanceSettings.CommonResourceFiles[0].FilePath, requestParameters.MultiInstanceSettings.CommonResourceFiles[0].FilePath);
Assert.Equal(cmdlet.ResourceFiles.Length, requestParameters.ResourceFiles.Count);
Assert.Equal(cmdlet.ResourceFiles.Single().HttpUrl, requestParameters.ResourceFiles.Single().HttpUrl);
}
public void NewBatchTaskAuthTokenSettingsGetsPassedToRequest()
{
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
cmdlet.Id = "testTask";
cmdlet.JobId = "testJob";
cmdlet.CommandLine = "cmd /c echo hello";
cmdlet.AuthenticationTokenSettings = new PSAuthenticationTokenSettings
{
Access = Azure.Batch.Common.AccessScope.Job
};
TaskAddParameter requestParameters = null;
// Store the request parameters
RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor <
TaskAddParameter,
TaskAddOptions,
AzureOperationHeaderResponse <TaskAddHeaders> >(requestAction: (r) =>
{
requestParameters = r.Parameters;
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
cmdlet.ExecuteCmdlet();
// Verify the request parameters match the cmdlet parameters
Assert.Equal(cmdlet.AuthenticationTokenSettings.Access.ToString().ToLowerInvariant(),
requestParameters.AuthenticationTokenSettings.Access.Single().ToString().ToLowerInvariant());
}
public void NewBatchTaskUserIdentityGetsPassedToRequest()
{
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
cmdlet.Id = "testTask";
cmdlet.JobId = "testJob";
cmdlet.CommandLine = "cmd /c echo hello";
cmdlet.UserIdentity = new PSUserIdentity(
new PSAutoUserSpecification(Azure.Batch.Common.AutoUserScope.Task, Azure.Batch.Common.ElevationLevel.Admin));
TaskAddParameter requestParameters = null;
// Store the request parameters
RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor <
TaskAddParameter,
TaskAddOptions,
AzureOperationHeaderResponse <TaskAddHeaders> >(requestAction: (r) =>
{
requestParameters = r.Parameters;
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
cmdlet.ExecuteCmdlet();
// Verify the request parameters match the cmdlet parameters
Assert.Equal(cmdlet.UserIdentity.AutoUser.Scope.ToString().ToLowerInvariant(),
requestParameters.UserIdentity.AutoUser.Scope.ToString().ToLowerInvariant());
Assert.Equal(cmdlet.UserIdentity.AutoUser.ElevationLevel.ToString().ToLowerInvariant(),
requestParameters.UserIdentity.AutoUser.ElevationLevel.ToString().ToLowerInvariant());
Assert.Null(requestParameters.UserIdentity.UserName);
// Set the user name instead and verify the request matches expectations
cmdlet.UserIdentity = new PSUserIdentity("user1");
cmdlet.ExecuteCmdlet();
Assert.Equal(cmdlet.UserIdentity.UserName, requestParameters.UserIdentity.UserName);
Assert.Null(requestParameters.UserIdentity.AutoUser);
}
private void ExitConditionsAreSentToService()
{
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
TaskAddParameter requestParameters = null;
RequestInterceptor interceptor = new RequestInterceptor((baseRequest) =>
{
TaskAddBatchRequest request = (TaskAddBatchRequest)baseRequest;
request.ServiceRequestFunc = (cancellationToken) =>
{
requestParameters = request.Parameters;
var response = new AzureOperationHeaderResponse <TaskAddHeaders>();
Task <AzureOperationHeaderResponse <TaskAddHeaders> > task = Task.FromResult(response);
return(task);
};
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior> {
interceptor
};
var none = new PSExitOptions(new Azure.Batch.ExitOptions {
JobAction = Azure.Batch.Common.JobAction.None
});
var terminate = new PSExitOptions(new Azure.Batch.ExitOptions {
JobAction = Azure.Batch.Common.JobAction.Terminate
});
var satisfyDependency = new PSExitOptions(new Azure.Batch.ExitOptions {
DependencyAction = Azure.Batch.Common.DependencyAction.Satisfy
});
cmdlet.ExitConditions = new PSExitConditions
{
ExitCodes = new List <PSExitCodeMapping> {
new PSExitCodeMapping(0, none)
},
PreProcessingError = terminate,
FileUploadError = none,
ExitCodeRanges = new List <PSExitCodeRangeMapping> {
new PSExitCodeRangeMapping(1, 5, satisfyDependency)
},
Default = none,
};
cmdlet.JobId = "job-Id";
cmdlet.Id = "task-id";
cmdlet.ExecuteCmdlet();
var exitConditions = requestParameters.ExitConditions;
Assert.Equal(1, exitConditions.ExitCodeRanges.First().Start);
Assert.Equal(5, exitConditions.ExitCodeRanges.First().End);
Assert.Equal(ProxyModels.DependencyAction.Satisfy, exitConditions.ExitCodeRanges.First().ExitOptions.DependencyAction);
Assert.Equal(ProxyModels.JobAction.None, exitConditions.ExitCodes.First().ExitOptions.JobAction);
Assert.Equal(ProxyModels.JobAction.Terminate, exitConditions.PreProcessingError.JobAction);
Assert.Equal(ProxyModels.JobAction.None, exitConditions.FileUploadError.JobAction);
Assert.Equal(ProxyModels.JobAction.None, exitConditions.DefaultProperty.JobAction);
}
/// <summary>
/// Adds a Task to the specified Job.
/// </summary>
/// <remarks>
/// The maximum lifetime of a Task from addition to completion is 180 days. If
/// a Task has not completed within 180 days of being added it will be
/// terminated by the Batch service and left in whatever state it was in at
/// that time.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='jobId'>
/// The ID of the Job to which the Task is to be added.
/// </param>
/// <param name='task'>
/// The Task to be added.
/// </param>
/// <param name='taskAddOptions'>
/// Additional parameters for the operation
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <TaskAddHeaders> AddAsync(this ITaskOperations operations, string jobId, TaskAddParameter task, TaskAddOptions taskAddOptions = default(TaskAddOptions), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.AddWithHttpMessagesAsync(jobId, task, taskAddOptions, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Headers);
}
}
/// <summary>
/// Adds a Task to the specified Job.
/// </summary>
/// <remarks>
/// The maximum lifetime of a Task from addition to completion is 180 days. If
/// a Task has not completed within 180 days of being added it will be
/// terminated by the Batch service and left in whatever state it was in at
/// that time.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='jobId'>
/// The ID of the Job to which the Task is to be added.
/// </param>
/// <param name='task'>
/// The Task to be added.
/// </param>
/// <param name='taskAddOptions'>
/// Additional parameters for the operation
/// </param>
public static TaskAddHeaders Add(this ITaskOperations operations, string jobId, TaskAddParameter task, TaskAddOptions taskAddOptions = default(TaskAddOptions))
{
return(operations.AddAsync(jobId, task, taskAddOptions).GetAwaiter().GetResult());
}
/// <summary>
/// Adds a task to the specified job.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='jobId'>
/// The id of the job to which the task is to be added.
/// </param>
/// <param name='task'>
/// The task to be added.
/// </param>
/// <param name='taskAddOptions'>
/// Additional parameters for the operation
/// </param>
public static TaskAddHeaders Add(this ITaskOperations operations, string jobId, TaskAddParameter task, TaskAddOptions taskAddOptions = default(TaskAddOptions))
{
return(System.Threading.Tasks.Task.Factory.StartNew(s => ((ITaskOperations)s).AddAsync(jobId, task, taskAddOptions), operations, System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
