public void TestRandomBoundComputeNodeProperties()
{
using BatchClient client = ClientUnitTestCommon.CreateDummyClient();
for (int i = 0; i < TestRunCount; i++)
{
Protocol.Models.ComputeNode computeNodeModel =
this.customizedObjectFactory.GenerateNew <Protocol.Models.ComputeNode>();
ComputeNode boundComputeNode = new ComputeNode(client, "Foo", computeNodeModel, client.CustomBehaviors);
ObjectComparer.CheckEqualityResult result = this.objectComparer.CheckEquality(boundComputeNode, computeNodeModel);
Assert.True(result.Equal, result.Message);
}
}
public void TestComputeNodeCertificateReferencesAreReadOnly()
{
using (BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient())
{
var protoComputeNode = new Protocol.Models.ComputeNode()
{
CertificateReferences = new List <Protocol.Models.CertificateReference>
{
new Protocol.Models.CertificateReference(
thumbprint: "1234",
thumbprintAlgorithm: "SHA1",
storeLocation: Protocol.Models.CertificateStoreLocation.CurrentUser,
storeName: "My",
visibility: new List <Protocol.Models.CertificateVisibility>
{
Protocol.Models.CertificateVisibility.Task
})
}
};
ComputeNode computeNode = batchClient.PoolOperations.GetComputeNode(
"dummy",
"dummy",
additionalBehaviors: InterceptorFactory.CreateGetComputeNodeRequestInterceptor(protoComputeNode));
CertificateReference computeNodeCertificateReference = computeNode.CertificateReferences.First();
// reads are allowed
this.testOutputHelper.WriteLine("{0}", computeNodeCertificateReference.StoreLocation);
this.testOutputHelper.WriteLine("{0}", computeNodeCertificateReference.StoreName);
this.testOutputHelper.WriteLine("{0}", computeNodeCertificateReference.Thumbprint);
this.testOutputHelper.WriteLine("{0}", computeNodeCertificateReference.ThumbprintAlgorithm);
this.testOutputHelper.WriteLine("{0}", computeNodeCertificateReference.Visibility);
// writes are foribdden
Assert.Throws <InvalidOperationException>(() => { computeNodeCertificateReference.StoreLocation = CertStoreLocation.CurrentUser; });
Assert.Throws <InvalidOperationException>(() => { computeNodeCertificateReference.StoreName = "x"; });
Assert.Throws <InvalidOperationException>(() => { computeNodeCertificateReference.Thumbprint = "y"; });
Assert.Throws <InvalidOperationException>(() => { computeNodeCertificateReference.ThumbprintAlgorithm = "z"; });
Assert.Throws <InvalidOperationException>(() => { computeNodeCertificateReference.Visibility = CertificateVisibility.None; });
}
}
public void Bug2329884_ComputeNodeRecentTasksAndComputeNodeError()
{
Action test = () =>
{
using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
{
string jobId = "Bug2329884Job-" + TestUtilities.GetMyName();
Protocol.RequestInterceptor interceptor = null;
try
{
const string taskId = "hiWorld";
//
// Create the job
//
CloudJob unboundJob = batchCli.JobOperations.CreateJob(jobId, new PoolInformation());
unboundJob.PoolInformation.PoolId = this.poolFixture.PoolId;
unboundJob.Commit();
CloudJob boundJob = batchCli.JobOperations.GetJob(jobId);
CloudTask myTask = new CloudTask(taskId, "cmd /c echo hello world");
boundJob.AddTask(myTask);
this.testOutputHelper.WriteLine("Initial job commit()");
//
// Wait for task to go to completion
//
Utilities utilities = batchCli.Utilities;
TaskStateMonitor taskStateMonitor = utilities.CreateTaskStateMonitor();
taskStateMonitor.WaitAll(
boundJob.ListTasks(),
Microsoft.Azure.Batch.Common.TaskState.Completed,
new TimeSpan(0, 3 /*min*/, 0));
CloudTask boundTask = boundJob.GetTask(taskId);
//Since the compute node name comes back as "Node:<computeNodeId>" we need to split on : to get the actual compute node name
string computeNodeId = boundTask.ComputeNodeInformation.AffinityId.Split(':')[1];
//
// Check recent tasks
//
ComputeNode computeNode = batchCli.PoolOperations.GetComputeNode(this.poolFixture.PoolId, computeNodeId);
this.testOutputHelper.WriteLine("Recent tasks:");
foreach (TaskInformation recentTask in computeNode.RecentTasks)
{
this.testOutputHelper.WriteLine("Compute node has recent task Job: {0}, Task: {1}, State: {2}, Subtask: {3}",
recentTask.JobId,
recentTask.TaskId,
recentTask.TaskState,
recentTask.SubtaskId);
}
TaskInformation myTaskInfo = computeNode.RecentTasks.First(taskInfo => taskInfo.JobId.Equals(
jobId, StringComparison.InvariantCultureIgnoreCase) &&
taskInfo.TaskId.Equals(taskId, StringComparison.InvariantCultureIgnoreCase));
Assert.Equal(TaskState.Completed, myTaskInfo.TaskState);
Assert.NotNull(myTaskInfo.ExecutionInformation);
Assert.Equal(0, myTaskInfo.ExecutionInformation.ExitCode);
//
// Check compute node Error
//
const string expectedErrorCode = "TestErrorCode";
const string expectedErrorMessage = "Test error message";
const string nvpValue = "Test";
//We use mocking to return a fake compute node object here to test Compute Node Error because we cannot force one easily
interceptor = new Protocol.RequestInterceptor((req =>
{
if (req is ComputeNodeGetBatchRequest)
{
var typedRequest = req as ComputeNodeGetBatchRequest;
typedRequest.ServiceRequestFunc = (token) =>
{
var response = new AzureOperationResponse <Protocol.Models.ComputeNode, Protocol.Models.ComputeNodeGetHeaders>();
List <Protocol.Models.ComputeNodeError> errors =
new List <Protocol.Models.ComputeNodeError>();
//Generate first Compute Node Error
List <Protocol.Models.NameValuePair> nvps =
new List <Protocol.Models.NameValuePair>();
nvps.Add(new Protocol.Models.NameValuePair()
{
Name = nvpValue, Value = nvpValue
});
Protocol.Models.ComputeNodeError error1 = new Protocol.Models.ComputeNodeError();
error1.Code = expectedErrorCode;
error1.Message = expectedErrorMessage;
error1.ErrorDetails = nvps;
errors.Add(error1);
//Generate second Compute Node Error
nvps = new List <Protocol.Models.NameValuePair>();
nvps.Add(new Protocol.Models.NameValuePair()
{
Name = nvpValue, Value = nvpValue
});
Protocol.Models.ComputeNodeError error2 = new Protocol.Models.ComputeNodeError();
error2.Code = expectedErrorCode;
error2.Message = expectedErrorMessage;
error2.ErrorDetails = nvps;
errors.Add(error2);
Protocol.Models.ComputeNode protoComputeNode = new Protocol.Models.ComputeNode();
protoComputeNode.Id = computeNodeId;
protoComputeNode.State = Protocol.Models.ComputeNodeState.Idle;
protoComputeNode.Errors = errors;
response.Body = protoComputeNode;
return(Task.FromResult(response));
};
}
}));
batchCli.PoolOperations.CustomBehaviors.Add(interceptor);
computeNode = batchCli.PoolOperations.GetComputeNode(this.poolFixture.PoolId, computeNodeId);
Assert.Equal(computeNodeId, computeNode.Id);
Assert.NotNull(computeNode.Errors);
Assert.Equal(2, computeNode.Errors.Count());
foreach (ComputeNodeError computeNodeError in computeNode.Errors)
{
Assert.Equal(expectedErrorCode, computeNodeError.Code);
Assert.Equal(expectedErrorMessage, computeNodeError.Message);
Assert.NotNull(computeNodeError.ErrorDetails);
Assert.Equal(1, computeNodeError.ErrorDetails.Count());
Assert.Contains(nvpValue, computeNodeError.ErrorDetails.First().Name);
}
}
finally
{
batchCli.JobOperations.DeleteJob(jobId);
}
}
};
SynchronizationContextHelper.RunTest(test, TestTimeout);
}
public static IEnumerable <Protocol.RequestInterceptor> CreateGetComputeNodeRequestInterceptor(Protocol.Models.ComputeNode nodeToReturn)
{
return(CreateGetRequestInterceptor <Protocol.Models.ComputeNodeGetOptions, Protocol.Models.ComputeNode, Protocol.Models.ComputeNodeGetHeaders>(nodeToReturn));
}
