public void TestPatchJob_ThrowsOnUnbound()
{
using BatchClient client = ClientUnitTestCommon.CreateDummyClient();
CloudJob job = client.JobOperations.CreateJob();
Assert.Throws <InvalidOperationException>(() => job.CommitChanges());
}
public void CloudJobSchedule_WhenSendingToTheServer_HasExpectedUnboundProperties()
{
const string jobScheduleId = "id-123";
const string displayName = "DisplayNameFoo";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
BatchSharedKeyCredentials credentials = ClientUnitTestCommon.CreateDummySharedKeyCredential();
using (BatchClient client = BatchClient.Open(credentials))
{
CloudJobSchedule jobSchedule = client.JobScheduleOperations.CreateJobSchedule();
jobSchedule.Id = jobScheduleId;
jobSchedule.DisplayName = displayName;
jobSchedule.Metadata = new List <MetadataItem> {
metadataItem
};
Assert.Equal(jobSchedule.Id, jobScheduleId); // can set an unbound object
Assert.Equal(jobSchedule.Metadata.First().Name, metadataItem.Name);
Assert.Equal(jobSchedule.Metadata.First().Value, metadataItem.Value);
jobSchedule.Commit(additionalBehaviors: InterceptorFactory.CreateAddJobScheduleRequestInterceptor());
// writing isn't allowed for a jobSchedule that is in an read only state.
Assert.Throws <InvalidOperationException>(() => jobSchedule.Id = "cannot-change-id");
Assert.Throws <InvalidOperationException>(() => jobSchedule.DisplayName = "cannot-change-display-name");
//Can still read though
Assert.Equal(jobScheduleId, jobSchedule.Id);
Assert.Equal(displayName, jobSchedule.DisplayName);
}
}
public void CannotModifyUsesTaskDependenciesOnAJobScheduleAfterItHasBeenCommitted()
{
const bool usesTaskDependencies = true;
using BatchClient client = ClientUnitTestCommon.CreateDummyClient();
Protocol.RequestInterceptor interceptor = new Protocol.RequestInterceptor(
baseRequest =>
{
var request = (Protocol.BatchRequests.JobScheduleAddBatchRequest)baseRequest;
request.ServiceRequestFunc = token =>
{
var response = new AzureOperationHeaderResponse <Models.JobScheduleAddHeaders> {
Response = new HttpResponseMessage(HttpStatusCode.Created)
};
return(Task.FromResult(response));
};
});
Microsoft.Azure.Batch.CloudJobSchedule cloudJobSchedule = client.JobScheduleOperations.CreateJobSchedule();
Microsoft.Azure.Batch.JobSpecification jobSpec = new Microsoft.Azure.Batch.JobSpecification(poolInformation: null)
{
UsesTaskDependencies = usesTaskDependencies
};
cloudJobSchedule.JobSpecification = jobSpec;
cloudJobSchedule.Commit(new List <BatchClientBehavior> {
interceptor
});
// writing isn't allowed for a CloudJobSchedule.JobSpecification.UsesTaskDependencies that is in an invalid state.
Assert.Throws <InvalidOperationException>(() => cloudJobSchedule.JobSpecification.UsesTaskDependencies = false);
}
public async Task UnboundJobScheduleCommitAndRefreshWorks()
{
using (BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient())
{
const string id = "Bar";
const string displayName = "Baz";
var jobSpecification = new Protocol.Models.JobSpecification()
{
DisplayName = displayName
};
var protoJobSchedule = new Protocol.Models.CloudJobSchedule(
id: id,
displayName: displayName,
jobSpecification: jobSpecification);
CloudJobSchedule jobSchedule = batchClient.JobScheduleOperations.CreateJobSchedule(id, new Schedule(), null);
await jobSchedule.CommitAsync(additionalBehaviors : InterceptorFactory.CreateAddJobScheduleRequestInterceptor());
await jobSchedule.RefreshAsync(additionalBehaviors : InterceptorFactory.CreateGetJobScheduleRequestInterceptor(protoJobSchedule));
Assert.Equal(id, jobSchedule.Id);
Assert.Equal(displayName, jobSchedule.DisplayName);
Assert.Null(jobSchedule.Schedule);
Assert.NotNull(jobSchedule.JobSpecification);
Assert.Equal(jobSpecification.DisplayName, jobSchedule.JobSpecification.DisplayName);
}
}
public async Task TestBatchClientDefaultHttpClientTimeoutInfinite()
{
BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient();
Protocol.BatchServiceClient restClient = (Protocol.BatchServiceClient) typeof(ProtocolLayer).GetField("_client", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(batchClient.ProtocolLayer);
Assert.Equal(Timeout.InfiniteTimeSpan, restClient.HttpClient.Timeout);
}
public async Task TaskStateMonitorTimedOut_ThrowsTimeoutException()
{
TimeSpan timeout = TimeSpan.FromSeconds(0);
const string dummyJobId = "Dummy";
using (BatchClient batchCli = BatchClient.Open(ClientUnitTestCommon.CreateDummySharedKeyCredential()))
{
List <string> taskIds = new List <string>()
{
"task1",
"task2"
};
//Create some tasks which are "bound"
IEnumerable <Protocol.Models.CloudTask> protocolTasks = taskIds.Select(CreateProtocolCloudTask);
IEnumerable <CloudTask> taskList = protocolTasks.Select(protoTask => CreateBoundCloudTask(batchCli, dummyJobId, protoTask));
TaskStateMonitor taskStateMonitor = batchCli.Utilities.CreateTaskStateMonitor();
TimeoutException e = await Assert.ThrowsAsync <TimeoutException>(async() => await taskStateMonitor.WhenAll(
taskList,
TaskState.Completed,
timeout,
additionalBehaviors: InterceptorFactory.CreateListTasksRequestInterceptor(protocolTasks)));
Assert.Contains(string.Format("waiting for resources after {0}", timeout), e.Message);
Assert.IsType <OperationCanceledException>(e.InnerException);
}
}
public async Task TaskStateMonitorCancelled_ThrowsCancellationException()
{
TimeSpan timeout = TimeSpan.FromSeconds(0);
const string dummyJobId = "Dummy";
using (BatchClient batchCli = BatchClient.Open(ClientUnitTestCommon.CreateDummySharedKeyCredential()))
{
List <string> taskIds = new List <string>()
{
"task1",
"task2"
};
//Create some tasks which are "bound"
IEnumerable <Protocol.Models.CloudTask> protocolTasks = taskIds.Select(CreateProtocolCloudTask);
IEnumerable <CloudTask> taskList = protocolTasks.Select(protoTask => CreateBoundCloudTask(batchCli, dummyJobId, protoTask));
TaskStateMonitor taskStateMonitor = batchCli.Utilities.CreateTaskStateMonitor();
using (CancellationTokenSource cts = new CancellationTokenSource(timeout))
{
await Assert.ThrowsAsync <OperationCanceledException>(async() => await taskStateMonitor.WhenAll(
taskList,
TaskState.Completed,
cts.Token,
additionalBehaviors: InterceptorFactory.CreateListTasksRequestInterceptor(protocolTasks)));
}
}
}
public async Task UnboundCertificateCommitAndRefreshWorks()
{
using (BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient())
{
string pfxFilePath = TestCommon.GetTemporaryCertificateFilePath("unboundcertificateunittest.pfx");
try
{
CertificateBuilder.CreateSelfSignedInFile("test", pfxFilePath, CommonResources.CertificatePassword);
const string expectedThumbprint = "ABC";
var protoCertificate = new Protocol.Models.Certificate(thumbprint: expectedThumbprint);
Certificate certificate = batchClient.CertificateOperations.CreateCertificate(
pfxFilePath,
CommonResources.CertificatePassword);
Assert.NotNull(certificate.ThumbprintAlgorithm);
await certificate.CommitAsync(additionalBehaviors : InterceptorFactory.CreateAddCertificateRequestInterceptor());
await certificate.RefreshAsync(additionalBehaviors : InterceptorFactory.CreateGetCertificateRequestInterceptor(protoCertificate));
Assert.Equal(expectedThumbprint, certificate.Thumbprint);
Assert.Null(certificate.ThumbprintAlgorithm);
}
finally
{
File.Delete(pfxFilePath);
}
}
}
public void WhenATaskIsRetrievedFromTheService_ItsDependenciesAreSurfacedCorrectly()
{
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
var returnFakeTasks = ClientUnitTestCommon.SimulateServiceResponse <Models.TaskListOptions, AzureOperationResponse <IPage <Models.CloudTask>, Models.TaskListHeaders> >(_ =>
new AzureOperationResponse <IPage <Models.CloudTask>, Models.TaskListHeaders>
{
Body = new FakePage <Models.CloudTask>(new []
{
new Protocol.Models.CloudTask
{
DependsOn = new Protocol.Models.TaskDependencies
{
TaskIdRanges = new[] { new Protocol.Models.TaskIdRange(5, 15) },
TaskIds = new List <string> {
"5"
}
},
Id = "5",
State = Models.TaskState.Active,
}
})
});
var tasks = client.JobOperations.ListTasks("job", additionalBehaviors: returnFakeTasks).ToList();
var taskDependencies = tasks.First().DependsOn;
Assert.Equal("5", taskDependencies.TaskIds.Single());
Assert.Equal(5, taskDependencies.TaskIdRanges.Single().Start);
Assert.Equal(15, taskDependencies.TaskIdRanges.Single().End);
}
}
public async Task TestCancellationViaParameterForLists()
{
using BatchClient client = ClientUnitTestCommon.CreateDummyClient();
List <IInheritedBehaviors> objectsToExamineForMethods = new List <IInheritedBehaviors>()
{
client.JobOperations,
client.JobScheduleOperations,
client.CertificateOperations,
client.PoolOperations,
};
foreach (IInheritedBehaviors behaviorContainer in objectsToExamineForMethods)
{
List <MethodInfo> listMethods = DiscoverListMethods(behaviorContainer.GetType());
//Call the list methods to build the enumerable
foreach (MethodInfo listMethod in listMethods)
{
behaviorContainer.CustomBehaviors.Clear();
behaviorContainer.CustomBehaviors.Add(CreateRequestInterceptorForCancellationMonitoring());
object pagedEnumerable = ReflectionHelpers.InvokeMethodWithDefaultArguments(listMethod, behaviorContainer);
//PagedEnumerable will have a method called: "GetPagedEnumerator"
MethodInfo getEnumeratorMethod = pagedEnumerable.GetType().GetMethod("GetPagedEnumerator");
object pagedEnumerator = getEnumeratorMethod.Invoke(pagedEnumerable, null);
//pagedEnumerator has the method to call "MoveNextAsync"
MethodInfo moveNextAsyncMethod = pagedEnumerator.GetType().GetMethod("MoveNextAsync");
await this.BatchRequestCancellationViaParameterTestAsync(moveNextAsyncMethod, pagedEnumerator, TimeSpan.FromSeconds(0));
}
}
}
public async Task TestRequestWhichDoesSupportSelect()
{
using (BatchClient client = await BatchClient.OpenAsync(ClientUnitTestCommon.CreateDummySharedKeyCredential()))
{
ODATADetailLevel detailLevel = new ODATADetailLevel(selectClause: "foo");
bool wasHit = false;
BatchClientBehavior behavior = new Protocol.RequestInterceptor(request =>
{
PoolGetBatchRequest poolGetRequest = request as PoolGetBatchRequest;
poolGetRequest.ServiceRequestFunc = t =>
{
Assert.Equal(detailLevel.SelectClause, poolGetRequest.Options.Select);
wasHit = true; //Ensure the interceptor was hit
return(Task.FromResult(new AzureOperationResponse <CloudPool, PoolGetHeaders>()
{
Body = new CloudPool()
}));
};
});
const string dummyPoolId = "dummy";
await client.PoolOperations.GetPoolAsync(dummyPoolId, detailLevel, new[] { behavior });
Assert.True(wasHit);
}
}
public void CannotSetUsesTaskDependenciesFromABoundCloudJob()
{
const string jobId = "id-123";
const bool usesTaskDependencies = true;
// Bound
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
Protocol.RequestInterceptor interceptor = new Protocol.RequestInterceptor(
baseRequest =>
{
var request = (Protocol.BatchRequest <Models.JobGetOptions, AzureOperationResponse <Models.CloudJob, Models.JobGetHeaders> >)baseRequest;
request.ServiceRequestFunc = (token) =>
{
var response = new AzureOperationResponse <Models.CloudJob, Models.JobGetHeaders>
{
Body = new Protocol.Models.CloudJob {
UsesTaskDependencies = usesTaskDependencies
}
};
return(Task.FromResult(response));
};
});
var cloudJob = client.JobOperations.GetJob(jobId, additionalBehaviors: new List <BatchClientBehavior> {
interceptor
});
Assert.Equal(usesTaskDependencies, cloudJob.UsesTaskDependencies);
Assert.Throws <InvalidOperationException>(() => cloudJob.UsesTaskDependencies = false);
}
}
public void Pool_WhenReturnedFromServer_HasExpectedBoundProperties()
{
const string cloudPoolId = "id-123";
const string cloudPoolDisplayName = "pool-display-name-test";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
Models.CloudPool protoPool = new Models.CloudPool(id: cloudPoolId, displayName: cloudPoolDisplayName, metadata: new[]
{
new Models.MetadataItem
{
Name = metadataItem.Name,
Value = metadataItem.Value
}
});
CloudPool boundPool = client.PoolOperations.GetPool(string.Empty, additionalBehaviors: InterceptorFactory.CreateGetPoolRequestInterceptor(protoPool));
// Cannot change these bound properties.
Assert.Throws <InvalidOperationException>(() => boundPool.DisplayName = "cannot-change-display-name");
Assert.Throws <InvalidOperationException>(() => boundPool.Id = "cannot-change-id");
Assert.Throws <InvalidOperationException>(() => boundPool.TargetDedicatedComputeNodes = 1);
Assert.Throws <InvalidOperationException>(() => boundPool.VirtualMachineSize = "cannot-change-1");
// Swap the value with the name and the name with the value.
boundPool.Metadata = new[] { new MetadataItem(metadataItem.Value, metadataItem.Name) };
Assert.Equal(metadataItem.Name, boundPool.Metadata.First().Value);
Assert.Equal(metadataItem.Value, boundPool.Metadata.First().Name);
}
}
public void CreateJobWithApplicationReferencesTest()
{
const string applicationId = "blender.exe";
const string version = "blender";
const string jobId = "mock-job";
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
Microsoft.Azure.Batch.PoolInformation autoPoolSpecification = new Microsoft.Azure.Batch.PoolInformation
{
AutoPoolSpecification = new Microsoft.Azure.Batch.AutoPoolSpecification
{
KeepAlive = false,
PoolSpecification = new Microsoft.Azure.Batch.PoolSpecification
{
ApplicationPackageReferences = new List <Microsoft.Azure.Batch.ApplicationPackageReference>
{
new Microsoft.Azure.Batch.ApplicationPackageReference
{
ApplicationId = applicationId,
Version = version
}
},
AutoScaleEnabled = false
}
}
};
Microsoft.Azure.Batch.CloudJob cloudJob = client.JobOperations.CreateJob(jobId, autoPoolSpecification);
Assert.Equal(cloudJob.PoolInformation.AutoPoolSpecification.PoolSpecification.ApplicationPackageReferences.First().ApplicationId, applicationId);
Assert.Equal(cloudJob.PoolInformation.AutoPoolSpecification.PoolSpecification.ApplicationPackageReferences.First().Version, version);
}
}
public async Task TestCancellationViaParameter()
{
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
List <IInheritedBehaviors> objectsToExamineForMethods = new List <IInheritedBehaviors>()
{
client.JobOperations,
client.JobScheduleOperations,
client.CertificateOperations,
client.PoolOperations,
};
foreach (IInheritedBehaviors o in objectsToExamineForMethods)
{
List <MethodInfo> methodsToCall = DiscoverCancellableMethods(o.GetType());
foreach (MethodInfo method in methodsToCall)
{
foreach (IInheritedBehaviors behaviorContainer in objectsToExamineForMethods)
{
behaviorContainer.CustomBehaviors.Clear();
behaviorContainer.CustomBehaviors.Add(CreateRequestInterceptorForCancellationMonitoring());
}
await this.BatchRequestCancellationViaParameterTestAsync(method, o, TimeSpan.FromSeconds(0));
}
}
}
}
public void CannotModifyDependenciesOfABoundTask()
{
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
var returnFakeTasks = ClientUnitTestCommon.SimulateServiceResponse <Models.TaskGetOptions, AzureOperationResponse <Models.CloudTask, Models.TaskGetHeaders> >(_ =>
new AzureOperationResponse <Models.CloudTask, Models.TaskGetHeaders>
{
Body = new Protocol.Models.CloudTask
{
DependsOn = new Protocol.Models.TaskDependencies
{
TaskIdRanges = new[] { new Protocol.Models.TaskIdRange(5, 15) },
TaskIds = new List <string> {
"5"
}
},
Id = "5",
State = Models.TaskState.Active,
}
});
var task = client.JobOperations.GetTask("job", "5", additionalBehaviors: returnFakeTasks);
var newDependencies = Microsoft.Azure.Batch.TaskDependencies.OnId("hello");
Assert.Throws <InvalidOperationException>(() => task.DependsOn = newDependencies);
}
}
public async Task TestBatchRequestCannotBeModifiedAfterExecutionStarted()
{
using (BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient())
{
Protocol.RequestInterceptor interceptor = new Protocol.RequestInterceptor(req =>
{
PoolAddBatchRequest addPoolRequest = req as PoolAddBatchRequest;
addPoolRequest.ServiceRequestFunc = token =>
{
Assert.Throws <InvalidOperationException>(() => addPoolRequest.CancellationToken = CancellationToken.None);
Assert.Throws <InvalidOperationException>(() => addPoolRequest.Options = null);
Assert.Throws <InvalidOperationException>(() => addPoolRequest.RetryPolicy = null);
Assert.Throws <InvalidOperationException>(() => addPoolRequest.ServiceRequestFunc = null);
Assert.Throws <InvalidOperationException>(() => addPoolRequest.Timeout = TimeSpan.FromSeconds(0));
Assert.Throws <InvalidOperationException>(() => addPoolRequest.ClientRequestIdProvider = null);
Assert.Throws <InvalidOperationException>(() => addPoolRequest.Parameters = null);
return(Task.FromResult(new AzureOperationHeaderResponse <Protocol.Models.PoolAddHeaders>()));
};
});
CloudPool pool = batchClient.PoolOperations.CreatePool("dummy", "small", default(CloudServiceConfiguration), targetDedicatedComputeNodes: 0);
await pool.CommitAsync(additionalBehaviors : new[] { interceptor });
}
}
public async Task UnboundPoolCommitAndRefreshWorks()
{
using (BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient())
{
const string id = "Bar";
const string displayName = "Baz";
var startTask = new Protocol.Models.StartTask("cmd /c dir");
var protoPool = new Protocol.Models.CloudPool(
id: id,
displayName: displayName,
startTask: startTask);
CloudPool pool = batchClient.PoolOperations.CreatePool(id, "Woo", new CloudServiceConfiguration("4"));
await pool.CommitAsync(additionalBehaviors : InterceptorFactory.CreateAddPoolRequestInterceptor());
await pool.RefreshAsync(additionalBehaviors : InterceptorFactory.CreateGetPoolRequestInterceptor(protoPool));
Assert.Equal(id, pool.Id);
Assert.Equal(displayName, pool.DisplayName);
Assert.Null(pool.CloudServiceConfiguration);
Assert.NotNull(pool.StartTask);
Assert.Equal(startTask.CommandLine, pool.StartTask.CommandLine);
}
}
public async Task UnboundJobCommitAndRefreshWorks()
{
using (BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient())
{
const string id = "Bar";
const string displayName = "Baz";
var prepTask = new Protocol.Models.JobPreparationTask(id);
Protocol.Models.CloudJob protoJob = new Protocol.Models.CloudJob(
id: id,
displayName: displayName,
jobPreparationTask: prepTask);
CloudJob job = batchClient.JobOperations.CreateJob(id, new PoolInformation()
{
PoolId = "Foo"
});
await job.CommitAsync(additionalBehaviors : InterceptorFactory.CreateAddJobRequestInterceptor());
await job.RefreshAsync(additionalBehaviors : InterceptorFactory.CreateGetJobRequestInterceptor(protoJob));
Assert.Equal(id, job.Id);
Assert.Equal(displayName, job.DisplayName);
Assert.Null(job.PoolInformation);
Assert.NotNull(job.JobPreparationTask);
Assert.Equal(prepTask.Id, job.JobPreparationTask.Id);
}
}
public void GetJobManagerTaskWithApplicationPackageReferences()
{
const string jobId = "id-123";
const string applicationId = "foo";
const string version = "beta";
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
Models.CloudJob protoJob = new Models.CloudJob
{
Id = jobId,
JobManagerTask = new Models.JobManagerTask
{
ApplicationPackageReferences = new List <Models.ApplicationPackageReference>
{
new Models.ApplicationPackageReference
{
Version = version, ApplicationId = applicationId
}
}
}
};
var job = client.JobOperations.GetJob(jobId, additionalBehaviors: InterceptorFactory.CreateGetJobRequestInterceptor(protoJob));
Assert.Equal(applicationId, job.JobManagerTask.ApplicationPackageReferences.First().ApplicationId);
Assert.Equal(version, job.JobManagerTask.ApplicationPackageReferences.First().Version);
}
}
public async Task TestDefaultBatchRequestTimeoutSet()
{
TimeSpan requestTimeout = TimeSpan.MinValue;
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
Protocol.RequestInterceptor interceptor = new Protocol.RequestInterceptor(req =>
{
requestTimeout = req.Timeout;
var castRequest = (Protocol.BatchRequest <
Protocol.Models.JobGetOptions,
AzureOperationResponse <Protocol.Models.CloudJob, Protocol.Models.JobGetHeaders> >)req;
castRequest.ServiceRequestFunc = (token) =>
{
return(Task.FromResult(new AzureOperationResponse <Protocol.Models.CloudJob, Protocol.Models.JobGetHeaders>()
{
Body = new Protocol.Models.CloudJob()
}));
};
});
await client.JobOperations.GetJobAsync("foo", additionalBehaviors : new List <BatchClientBehavior> {
interceptor
});
Assert.Equal(Constants.DefaultSingleRestRequestClientTimeout, requestTimeout);
}
}
public void CanReadUsesTaskDependenciesFromABoundCloudJobScheduleTest()
{
const string jobId = "id-123";
const bool usesTaskDependencies = true;
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
Protocol.RequestInterceptor interceptor = new Protocol.RequestInterceptor(
baseRequest =>
{
var request = (Protocol.BatchRequest <Models.JobScheduleGetOptions, AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders> >)baseRequest;
request.ServiceRequestFunc = token =>
{
var response = new AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders>
{
Body = new Protocol.Models.CloudJobSchedule(jobId, schedule: new Protocol.Models.Schedule(), jobSpecification: new Protocol.Models.JobSpecification()
{
UsesTaskDependencies = true
})
};
return(Task.FromResult(response));
};
});
Microsoft.Azure.Batch.CloudJobSchedule unboundCloudJob = client.JobScheduleOperations.GetJobSchedule(jobId, additionalBehaviors: new List <BatchClientBehavior> {
interceptor
});
Assert.Equal(usesTaskDependencies, unboundCloudJob.JobSpecification.UsesTaskDependencies);
}
}
public void CloudTask_WhenReturnedFromServer_HasExpectedBoundProperties()
{
const string jobId = "id-123";
const string taskId = "id-123";
const int exitCode = 1;
const int exitCodeRangeStart = 0;
const int exitCodeRangeEnd = 4;
Models.ExitOptions terminateExitOption = new Models.ExitOptions()
{
JobAction = Models.JobAction.Terminate
};
Models.ExitOptions disableExitOption = new Models.ExitOptions()
{
JobAction = Models.JobAction.Disable,
DependencyAction = Models.DependencyAction.Satisfy
};
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
Models.CloudTask cloudTask = new Models.CloudTask()
{
Id = jobId,
ExitConditions = new Models.ExitConditions()
{
DefaultProperty = disableExitOption,
ExitCodeRanges = new List <Models.ExitCodeRangeMapping>()
{
new Models.ExitCodeRangeMapping(exitCodeRangeStart, exitCodeRangeEnd, terminateExitOption)
},
ExitCodes = new List <Models.ExitCodeMapping>()
{
new Models.ExitCodeMapping(exitCode, terminateExitOption)
},
PreProcessingError = terminateExitOption,
FileUploadError = disableExitOption
}
};
CloudTask boundTask = client.JobOperations.GetTask(
jobId,
taskId,
additionalBehaviors: InterceptorFactory.CreateGetTaskRequestInterceptor(cloudTask));
Assert.Equal(taskId, boundTask.Id); // reading is allowed from a task that is returned from the server.
// These need to be compared as strings because they are different types but we are interested in the values being the same.
Assert.Equal(disableExitOption.JobAction.ToString(), boundTask.ExitConditions.Default.JobAction.ToString());
Assert.Equal(DependencyAction.Satisfy, boundTask.ExitConditions.Default.DependencyAction);
Assert.Equal(DependencyAction.Satisfy, boundTask.ExitConditions.FileUploadError.DependencyAction);
Assert.Throws <InvalidOperationException>(() => boundTask.ExitConditions = new ExitConditions());
Assert.Throws <InvalidOperationException>(() => boundTask.DependsOn = new TaskDependencies(new List <string>(), new List <TaskIdRange>()));
Assert.Throws <InvalidOperationException>(() => boundTask.UserIdentity = new UserIdentity("abc"));
Assert.Throws <InvalidOperationException>(() => boundTask.CommandLine = "Cannot change command line");
Assert.Throws <InvalidOperationException>(() => boundTask.ExitConditions.Default = new ExitOptions()
{
JobAction = JobAction.Terminate
});
}
}
public void CloudJob_WhenSendingToTheServer_HasExpectedUnboundProperties()
{
const string jobId = "id-123";
const string displayName = "DisplayNameFoo";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
const int priority = 0;
const string applicationId = "testApp";
const string applicationVersion = "beta";
using BatchClient client = ClientUnitTestCommon.CreateDummyClient();
CloudJob cloudJob = client.JobOperations.CreateJob(jobId, new PoolInformation {
AutoPoolSpecification = new AutoPoolSpecification {
KeepAlive = false
}
});
cloudJob.Id = jobId;
cloudJob.DisplayName = displayName;
cloudJob.Metadata = new List <MetadataItem> {
metadataItem
};
cloudJob.Priority = priority;
cloudJob.JobManagerTask = new JobManagerTask
{
ApplicationPackageReferences = new List <ApplicationPackageReference>
{
new ApplicationPackageReference {
ApplicationId = applicationId, Version = applicationVersion
}
},
AuthenticationTokenSettings = new AuthenticationTokenSettings()
{
Access = AccessScope.Job
}
};
cloudJob.OnAllTasksComplete = OnAllTasksComplete.NoAction;
cloudJob.OnTaskFailure = OnTaskFailure.NoAction;
Assert.Throws <InvalidOperationException>(() => cloudJob.Url); // cannot read a Url since it's unbound at this point.
Assert.Equal(cloudJob.Id, jobId); // can set an unbound object
Assert.Equal(cloudJob.Metadata.First().Name, metadataItem.Name);
Assert.Equal(cloudJob.Metadata.First().Value, metadataItem.Value);
Assert.Equal(OnAllTasksComplete.NoAction, cloudJob.OnAllTasksComplete);
Assert.Equal(OnTaskFailure.NoAction, cloudJob.OnTaskFailure);
cloudJob.Commit(additionalBehaviors: InterceptorFactory.CreateAddJobRequestInterceptor());
// writing isn't allowed for a job that is in an invalid state.
Assert.Throws <InvalidOperationException>(() => cloudJob.Id = "cannot-change-id");
Assert.Throws <InvalidOperationException>(() => cloudJob.DisplayName = "cannot-change-display-name");
AuthenticationTokenSettings authenticationTokenSettings = new AuthenticationTokenSettings {
Access = AccessScope.Job
};
Assert.Throws <InvalidOperationException>(() => { cloudJob.JobManagerTask.AuthenticationTokenSettings = authenticationTokenSettings; });
}
public void TestPatchJobSchedule_ThrowsOnUnbound()
{
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
CloudJobSchedule jobSchedule = client.JobScheduleOperations.CreateJobSchedule();
Assert.Throws <InvalidOperationException>(() => jobSchedule.CommitChanges());
}
}
public void TestPatchPool_ThrowsOnUnbound()
{
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
CloudPool pool = client.PoolOperations.CreatePool();
Assert.Throws <InvalidOperationException>(() => pool.CommitChanges());
}
}
public void GetPoolResizeError()
{
var autoScaleRunError = new Models.AutoScaleRunError
{
Code = "InsufficientSampleData",
Message = "Autoscale evaluation failed due to insufficient sample data",
Values = new List <Models.NameValuePair>
{
new Models.NameValuePair
{
Name = "Message",
Value = "Line 1, Col 24: Insufficient data from data set: $RunningTasks wanted 100%, received 0%"
}
}
};
var autoScaleError = new Models.AutoScaleRun {
Error = autoScaleRunError
};
BatchSharedKeyCredentials credentials = ClientUnitTestCommon.CreateDummySharedKeyCredential();
using (BatchClient client = BatchClient.Open(credentials))
{
Protocol.RequestInterceptor interceptor = new Protocol.RequestInterceptor(baseRequest =>
{
var request = (Protocol.BatchRequest <Models.PoolGetOptions, AzureOperationResponse <Models.CloudPool, Models.PoolGetHeaders> >)baseRequest;
request.ServiceRequestFunc = async(token) =>
{
var response = new AzureOperationResponse <Models.CloudPool, Models.PoolGetHeaders>
{
Body = new Models.CloudPool
{
DisplayName = "batch-test",
AutoScaleFormula = "$RunningTasks.GetSample(10 * TimeInterval_Second, 0 * TimeInterval_Second, 100);",
AutoScaleRun = autoScaleError,
EnableAutoScale = true,
}
};
var task = Task.FromResult(response);
return(await task);
};
});
var pool = client.PoolOperations.GetPool("batch-test", additionalBehaviors: new List <BatchClientBehavior> {
interceptor
});
Assert.Equal("batch-test", pool.DisplayName);
Assert.Equal(pool.AutoScaleEnabled, true);
Assert.Equal(pool.AutoScaleRun.Error.Code, "InsufficientSampleData");
Assert.Equal(pool.AutoScaleRun.Error.Message, "Autoscale evaluation failed due to insufficient sample data");
Assert.Equal(pool.AutoScaleRun.Error.Values.First().Name, "Message");
Assert.Equal(pool.AutoScaleRun.Error.Values.First().Value, "Line 1, Col 24: Insufficient data from data set: $RunningTasks wanted 100%, received 0%");
}
}
public async Task CreateJobScheduleWithApplicationPackageReferences()
{
const string applicationId = "blender.exe";
const string version = "blender";
const string jobId = "mock-job";
BatchSharedKeyCredentials credentials = ClientUnitTestCommon.CreateDummySharedKeyCredential();
using (BatchClient client = BatchClient.Open(credentials))
{
Protocol.RequestInterceptor interceptor = new Protocol.RequestInterceptor(
baseRequest =>
{
var request =
(Protocol.BatchRequest <Models.JobScheduleGetOptions, AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders> >)baseRequest;
request.ServiceRequestFunc = (token) =>
{
var response = new AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders>
{
Body = new Models.CloudJobSchedule
{
JobSpecification = new Protocol.Models.JobSpecification
{
PoolInfo = new Models.PoolInformation
{
AutoPoolSpecification = new Models.AutoPoolSpecification
{
Pool = new Models.PoolSpecification
{
ApplicationPackageReferences = new[]
{
new Protocol.Models.ApplicationPackageReference
{
ApplicationId = applicationId,
Version = version,
}
},
MaxTasksPerNode = 4
}
}
}
}
}
};
return(Task.FromResult(response));
};
});
Microsoft.Azure.Batch.CloudJobSchedule cloudJobSchedule = await client.JobScheduleOperations.GetJobScheduleAsync(jobId, additionalBehaviors : new List <BatchClientBehavior> {
interceptor
});
Assert.Equal(cloudJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification.ApplicationPackageReferences.First().ApplicationId, applicationId);
Assert.Equal(cloudJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification.ApplicationPackageReferences.First().Version, version);
}
}
public void CloudJob_WhenReturnedFromServer_HasExpectedBoundProperties()
{
const string jobId = "id-123";
const string displayName = "DisplayNameFoo";
string applicationVersion = "beta";
string applicationId = "test";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
const int priority = 0;
var onAllTasksComplete = OnAllTasksComplete.TerminateJob;
BatchSharedKeyCredentials credentials = ClientUnitTestCommon.CreateDummySharedKeyCredential();
using (BatchClient client = BatchClient.Open(credentials))
{
DateTime creationTime = DateTime.Now;
Models.CloudJob protoJob = new Models.CloudJob(
jobId,
displayName,
jobManagerTask: new Models.JobManagerTask()
{
ApplicationPackageReferences = new [] { new Models.ApplicationPackageReference()
{
ApplicationId = applicationId, Version = applicationVersion
} }
},
metadata: new[] { new Models.MetadataItem {
Name = metadataItem.Name, Value = metadataItem.Value
} },
creationTime: creationTime,
priority: priority,
url: ClientUnitTestCommon.DummyBaseUrl,
onAllTasksComplete: Models.OnAllTasksComplete.NoAction);
CloudJob boundJob = client.JobOperations.GetJob(jobId, additionalBehaviors: InterceptorFactory.CreateGetJobRequestInterceptor(protoJob));
Assert.Equal(jobId, boundJob.Id); // reading is allowed from a job that is returned from the server.
Assert.Equal(creationTime, boundJob.CreationTime);
Assert.Equal(displayName, boundJob.DisplayName);
Assert.Equal(applicationId, boundJob.JobManagerTask.ApplicationPackageReferences.First().ApplicationId);
Assert.Equal(applicationVersion, boundJob.JobManagerTask.ApplicationPackageReferences.First().Version);
AssertPatchableJobPropertiesCanBeWritten(boundJob, priority, metadataItem, onAllTasksComplete);
// Can only read a url from a returned object.
Assert.Equal(ClientUnitTestCommon.DummyBaseUrl, boundJob.Url);
// Cannot change a bound displayName, Id and any property on a JobManagerTask.
Assert.Throws <InvalidOperationException>(() => boundJob.DisplayName = "cannot-change-display-name");
Assert.Throws <InvalidOperationException>(() => boundJob.Id = "cannot-change-id");
Assert.Throws <InvalidOperationException>(() => boundJob.JobManagerTask.ApplicationPackageReferences = new List <ApplicationPackageReference>());
Assert.Throws <InvalidOperationException>(() => boundJob.JobManagerTask = new JobManagerTask());
}
}
public void CloudTask_WhenReturnedFromServer_HasExpectedBoundProperties()
{
const string jobId = "id-123";
const string taskId = "id-123";
const int exitCode = 1;
const int exitCodeRangeStart = 0;
const int exitCodeRangeEnd = 4;
Models.ExitOptions terminateExitOption = new Models.ExitOptions()
{
JobAction = Models.JobAction.Terminate
};
Models.ExitOptions disableExitOption = new Models.ExitOptions()
{
JobAction = Models.JobAction.Disable
};
BatchSharedKeyCredentials credentials = ClientUnitTestCommon.CreateDummySharedKeyCredential();
using (BatchClient client = BatchClient.Open(credentials))
{
Models.CloudTask cloudTask = new Models.CloudTask()
{
Id = jobId,
ExitConditions = new Models.ExitConditions()
{
DefaultProperty = disableExitOption,
ExitCodeRanges = new List <Models.ExitCodeRangeMapping>()
{
new Models.ExitCodeRangeMapping(exitCodeRangeStart, exitCodeRangeEnd, terminateExitOption)
},
ExitCodes = new List <Models.ExitCodeMapping>()
{
new Models.ExitCodeMapping(exitCode, terminateExitOption)
},
SchedulingError = terminateExitOption,
}
};
CloudTask boundTask = client.JobOperations.GetTask(
jobId,
taskId,
additionalBehaviors: InterceptorFactory.CreateGetTaskRequestInterceptor(cloudTask));
Assert.Equal(taskId, boundTask.Id); // reading is allowed from a task that is returned from the server.
Assert.Equal(disableExitOption.JobAction.ToString(), boundTask.ExitConditions.Default.JobAction.ToString());
Assert.Throws <InvalidOperationException>(() => boundTask.ExitConditions = new ExitConditions());
Assert.Throws <InvalidOperationException>(() => boundTask.DependsOn = new TaskDependencies(new List <string>(), new List <TaskIdRange>()));
Assert.Throws <InvalidOperationException>(() => boundTask.RunElevated = true);
Assert.Throws <InvalidOperationException>(() => boundTask.CommandLine = "Cannot change command line");
Assert.Throws <InvalidOperationException>(() => boundTask.ExitConditions.Default = new ExitOptions()
{
JobAction = JobAction.Terminate
});
}
}
