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 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 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);
}
}
private void InterceptMessage(T message)
{
Interceptor <T> intercepter = null;
try
{
intercepter = InterceptorFactory.GetInterceptor(message);
T forward = intercepter.OnSend(message);
// NOTE that if the output channel is not a synchronous channel, the intercepter will not
// control the context of that channel and the processing of the message
_output.Send(forward);
intercepter.OnComplete();
}
catch (Exception ex)
{
if (intercepter != null)
{
intercepter.OnException(ex);
}
throw;
}
}
public void TestDefaultValueWithError()
{
// Used to be:
//var ex = Assert.Throws<InvalidCastException>(() => ProxyBuilder.CreateProxy<IDefaultValueWithErrorTest>());
// Now it should run without error
InterceptorFactory.New <IDefaultValueWithErrorTest>();
}
public void TestCreateType_2x()
{
// Create via factory
InterceptorFactory.New <ISimpleTypeTest>();
var testInterfaceType = typeof(ISimpleTypeTest);
var typeName = testInterfaceType.Name + "Impl";
// Remove "I" at the start
if (typeName.StartsWith("I"))
{
typeName = typeName.Substring(1);
}
var fqTypeName = testInterfaceType.FullName.Replace(testInterfaceType.Name, typeName);
var baseType = typeof(ExtensibleInterceptorImpl <>);
// Make sure we have a non generic type, by filling in the "blanks"
if (baseType.IsGenericType)
{
baseType = baseType.MakeGenericType(testInterfaceType);
}
// Create self
var typeBuilder = IlTypeBuilder.CreateOrGet();
typeBuilder.CreateType(fqTypeName, new[] { testInterfaceType }, baseType);
}
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 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 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 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
});
}
}
public void CloudJobSchedule_WhenReturnedFromServer_HasExpectedBoundProperties()
{
const string jobScheduleId = "id-123";
const string displayName = "DisplayNameFoo";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
DateTime creationTime = DateTime.Now;
var cloudJobSchedule = new Models.CloudJobSchedule
{
Id = jobScheduleId,
DisplayName = displayName,
Metadata = new[]
{
new Models.MetadataItem {
Name = metadataItem.Name, Value = metadataItem.Value
}
},
CreationTime = creationTime,
JobSpecification = new Models.JobSpecification
{
OnAllTasksComplete = Models.OnAllTasksComplete.TerminateJob,
OnTaskFailure = Models.OnTaskFailure.PerformExitOptionsJobAction
}
};
CloudJobSchedule boundJobSchedule = client.JobScheduleOperations.GetJobSchedule(
jobScheduleId,
additionalBehaviors: InterceptorFactory.CreateGetJobScheduleRequestInterceptor(cloudJobSchedule));
Assert.Equal(jobScheduleId, boundJobSchedule.Id); // reading is allowed from a jobSchedule that is returned from the server.
Assert.Equal(creationTime, boundJobSchedule.CreationTime);
Assert.Equal(displayName, boundJobSchedule.DisplayName);
Assert.Equal(OnAllTasksComplete.TerminateJob, boundJobSchedule.JobSpecification.OnAllTasksComplete);
Assert.Equal(OnTaskFailure.PerformExitOptionsJobAction, boundJobSchedule.JobSpecification.OnTaskFailure);
Assert.Throws <InvalidOperationException>(() => boundJobSchedule.DisplayName = "cannot-change-display-name");
Assert.Throws <InvalidOperationException>(() => boundJobSchedule.Id = "cannot-change-id");
boundJobSchedule.JobSpecification.OnAllTasksComplete = OnAllTasksComplete.TerminateJob;
boundJobSchedule.JobSpecification.OnTaskFailure = OnTaskFailure.NoAction;
Assert.Equal(OnAllTasksComplete.TerminateJob, boundJobSchedule.JobSpecification.OnAllTasksComplete);
Assert.Equal(OnTaskFailure.NoAction, boundJobSchedule.JobSpecification.OnTaskFailure);
}
}
public void CloudJobSchedule_WhenSendingToTheServer_HasExpectedUnboundProperties()
{
const string jobScheduleId = "id-123";
const string displayName = "DisplayNameFoo";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
CloudJobSchedule jobSchedule = client.JobScheduleOperations.CreateJobSchedule();
jobSchedule.Id = jobScheduleId;
jobSchedule.DisplayName = displayName;
jobSchedule.Metadata = new List <MetadataItem> {
metadataItem
};
jobSchedule.JobSpecification = new JobSpecification
{
OnAllTasksComplete = OnAllTasksComplete.TerminateJob,
OnTaskFailure = OnTaskFailure.PerformExitOptionsJobAction
};
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);
Assert.Equal(OnAllTasksComplete.TerminateJob, jobSchedule.JobSpecification.OnAllTasksComplete);
Assert.Equal(OnTaskFailure.PerformExitOptionsJobAction, jobSchedule.JobSpecification.OnTaskFailure);
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);
jobSchedule.Refresh(additionalBehaviors:
InterceptorFactory.CreateGetJobScheduleRequestInterceptor(
new Models.CloudJobSchedule()
{
JobSpecification = new Models.JobSpecification()
}));
jobSchedule.JobSpecification.OnAllTasksComplete = OnAllTasksComplete.NoAction;
jobSchedule.JobSpecification.OnTaskFailure = OnTaskFailure.NoAction;
}
}
public async Task ExceptionOnClientError_ResultingExceptionContainsDetails()
{
const string expectedCode = "badness";
const string failingTaskId = "baz";
using (BatchClient batchCli = BatchClient.Open(ClientUnitTestCommon.CreateDummySharedKeyCredential()))
{
var tasksToAdd = new List <CloudTask>
{
new CloudTask("foo", "bar"),
new CloudTask(failingTaskId, "qux")
};
var results = new List <Protocol.Models.TaskAddResult>
{
new Protocol.Models.TaskAddResult(Protocol.Models.TaskAddStatus.Success, "foo"),
new Protocol.Models.TaskAddResult(
Protocol.Models.TaskAddStatus.Clienterror,
failingTaskId,
error: new Protocol.Models.BatchError(
expectedCode,
new Protocol.Models.ErrorMessage(value: "Test value"),
new List <Protocol.Models.BatchErrorDetail>
{
new Protocol.Models.BatchErrorDetail("key", "value")
}))
};
ParallelOperationsException parallelOperationsException = await Assert.ThrowsAsync <ParallelOperationsException>(
() => batchCli.JobOperations.AddTaskAsync(
"dummy",
tasksToAdd,
additionalBehaviors: InterceptorFactory.CreateAddTaskCollectionInterceptor(results)));
Assert.Equal(1, parallelOperationsException.InnerExceptions.Count);
var exception = parallelOperationsException.InnerException as AddTaskCollectionTerminatedException;
Assert.NotNull(exception);
Assert.NotNull(exception.AddTaskResult);
Assert.Equal(failingTaskId, exception.AddTaskResult.TaskId);
Assert.Equal(AddTaskStatus.ClientError, exception.AddTaskResult.Status);
Assert.Equal(expectedCode, exception.AddTaskResult.Error.Code);
Assert.Equal("Addition of a task failed with unexpected status code. Details: TaskId=baz, Status=ClientError, Error.Code=badness, Error.Message=Test value, Error.Values=[key=value]",
exception.Message);
}
}
protected override Expression VisitMethodCall(MethodCallExpression mExpr)
{
var interceptor = InterceptorFactory.FindInterceptor(mExpr);
if (interceptor != null)
{
interceptor.Intercept(Result, mExpr, (expr) => Visit(expr));
}
else
{
var compiled = Expression.Lambda(mExpr).Compile();
var constantExpression = Expression.Constant(compiled.DynamicInvoke(), mExpr.Type);
Visit(constantExpression);
}
return(mExpr);
}
public void Pool_WhenReturnedFromServer_HasExpectedUnboundProperties()
{
const string cloudPoolId = "id-123";
const string osFamily = "2";
const string virtualMachineSize = "4";
const string cloudPoolDisplayName = "pool-display-name-test";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
BatchSharedKeyCredentials credentials = ClientUnitTestCommon.CreateDummySharedKeyCredential();
using (BatchClient client = BatchClient.Open(credentials))
{
CloudPool cloudPool = client.PoolOperations.CreatePool(cloudPoolId, virtualMachineSize, new CloudServiceConfiguration(osFamily));
cloudPool.DisplayName = cloudPoolDisplayName;
cloudPool.Metadata = new List <MetadataItem> {
metadataItem
};
Assert.Equal(cloudPoolId, cloudPool.Id); // can set an unbound object
Assert.Equal(cloudPool.Metadata.First().Name, metadataItem.Name);
Assert.Equal(cloudPool.Metadata.First().Value, metadataItem.Value);
cloudPool.Commit(additionalBehaviors: InterceptorFactory.CreateAddPoolRequestInterceptor());
// writing isn't allowed for a cloudPool that is in an readonly state.
Assert.Throws <InvalidOperationException>(() => cloudPool.AutoScaleFormula = "Foo");
Assert.Throws <InvalidOperationException>(() => cloudPool.DisplayName = "Foo");
Assert.Throws <InvalidOperationException>(() => cloudPool.CloudServiceConfiguration = null);
Assert.Throws <InvalidOperationException>(() => cloudPool.ResizeTimeout = TimeSpan.FromSeconds(10));
Assert.Throws <InvalidOperationException>(() => cloudPool.Metadata = null);
Assert.Throws <InvalidOperationException>(() => cloudPool.TargetDedicated = 5);
Assert.Throws <InvalidOperationException>(() => cloudPool.VirtualMachineConfiguration = null);
Assert.Throws <InvalidOperationException>(() => cloudPool.VirtualMachineSize = "small");
//read is allowed though
Assert.Null(cloudPool.AutoScaleFormula);
Assert.Equal(cloudPoolDisplayName, cloudPool.DisplayName);
Assert.NotNull(cloudPool.CloudServiceConfiguration);
Assert.Null(cloudPool.ResizeTimeout);
Assert.Equal(1, cloudPool.Metadata.Count);
Assert.Null(cloudPool.TargetDedicated);
Assert.Null(cloudPool.VirtualMachineConfiguration);
Assert.Equal(virtualMachineSize, cloudPool.VirtualMachineSize);
}
}
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 async Task UnboundCertificateCommitAndRefreshWorks()
{
using BatchClient batchClient = ClientUnitTestCommon.CreateDummyClient();
const string expectedThumbprint = "ABC";
var protoCertificate = new Protocol.Models.Certificate(thumbprint: expectedThumbprint);
Certificate certificate = new Certificate(
batchClient,
null,
string.Empty,
expectedThumbprint,
"SHA1");
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);
}
private static void CommonPatchPoolTest(
Protocol.Models.CloudPool startEntity,
Action <CloudPool> modificationFunction,
Action <Protocol.Models.PoolPatchParameter> assertAction)
{
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
CloudPool pool = client.PoolOperations.GetPool(
string.Empty,
additionalBehaviors: InterceptorFactory.CreateGetPoolRequestInterceptor(startEntity));
modificationFunction(pool);
var patchInterceptor = ShimPatchPool(assertAction);
pool.CommitChanges(additionalBehaviors: new[] { patchInterceptor });
//Ensure that the job is in readable but unmodifiable state
var id = pool.Id;
Assert.Throws <InvalidOperationException>(() => pool.Metadata = null);
}
}
public virtual MethodInvokerEntry Get(MethodDescriptor methodDescriptor)
{
var result = InterceptorFactory.GetAllInterceptors(methodDescriptor, _services);
if (!_caches.TryGetValue(methodDescriptor, out var cache))
{
cache = new MethodInvokerEntry
{
Client = _goClient,
Codec = methodDescriptor.Codec,
Interceptors = result.Interceptors,
KeyValueFormatterFactory = _keyValueFormatterFactory,
TemplateParser = _templateParser,
UrlTemplate = new UrlDescriptor(methodDescriptor.UrlTemplate.Template)
};
_caches[methodDescriptor] = cache;
}
cache.Interceptors = result.Interceptors;
return(cache);
}
private static void CommonPatchJobTest(
Protocol.Models.CloudJob startEntity,
Action <CloudJob> modificationFunction,
Action <Protocol.Models.JobPatchParameter> assertAction)
{
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
CloudJob job = client.JobOperations.GetJob(
string.Empty,
additionalBehaviors: InterceptorFactory.CreateGetJobRequestInterceptor(startEntity));
modificationFunction(job);
var patchInterceptor = ShimPatchJob(assertAction);
job.CommitChanges(additionalBehaviors: new[] { patchInterceptor });
//Ensure that the job is in readable but unmodifiable state
var id = job.Id;
var priority = job.Priority;
Assert.Throws <InvalidOperationException>(() => job.Priority = 5);
}
}
public void CloudJobSchedule_WhenReturnedFromServer_HasExpectedBoundProperties()
{
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))
{
DateTime creationTime = DateTime.Now;
var cloudJobSchedule = new Models.CloudJobSchedule
{
Id = jobScheduleId,
DisplayName = displayName,
Metadata = new[]
{
new Models.MetadataItem {
Name = metadataItem.Name, Value = metadataItem.Value
}
},
CreationTime = creationTime
};
CloudJobSchedule boundJobSchedule = client.JobScheduleOperations.GetJobSchedule(
jobScheduleId,
additionalBehaviors: InterceptorFactory.CreateGetJobScheduleRequestInterceptor(cloudJobSchedule));
Assert.Equal(jobScheduleId, boundJobSchedule.Id); // reading is allowed from a jobSchedule that is returned from the server.
Assert.Equal(creationTime, boundJobSchedule.CreationTime);
Assert.Equal(displayName, boundJobSchedule.DisplayName);
Assert.Throws <InvalidOperationException>(() => boundJobSchedule.DisplayName = "cannot-change-display-name");
Assert.Throws <InvalidOperationException>(() => boundJobSchedule.Id = "cannot-change-id");
}
}
protected override InterceptorFactory <T> Visitor <T>(InterceptorFactory <T> factory)
{
Trace.WriteLine("InterceptorFactory<{0}>".FormatWith(typeof(T).Name));
return(base.Visitor(factory));
}
public virtual InterceptorFactory <T> Visit <T>(InterceptorFactory <T> factory)
{
InterceptorFactory <T> result = this.FastInvoke <ChannelVisitor, InterceptorFactory <T> >("Visitor", factory);
return(result);
}
protected virtual InterceptorFactory <T> Visitor <T>(InterceptorFactory <T> factory)
{
return(factory);
}
/// <summary>
/// Register a Func to run against any object of this PluginType immediately after it is created,
/// but before the new object is passed back to the caller. Unlike OnCreationForAll(),
/// DecorateAllWith() gives the the ability to return a different object. Use this method for runtime AOP
/// scenarios or to return a decorator.
/// </summary>
/// <param name="description">Descriptive text for diagnostics</param>
/// <param name="handler">Function that will create a decorator for the plugin type</param>
/// <param name="filter"></param>
public CreatePluginFamilyExpression <TPluginType> DecorateAllWith(string description,
Func <IContext, TPluginType, TPluginType> handler, Func <Instance, bool> filter = null)
{
return(InterceptWith(InterceptorFactory.ForFunc(description, handler), filter));
}
/// <summary>
/// Register an Action to run against any object of this PluginType immediately after
/// it is created, but before the new object is passed back to the caller
/// </summary>
/// <param name="description">Descriptive text for diagnostics</param>
/// <param name="handler"></param>
/// <param name="filter">If specified, limits the applicability of this activation interception</param>
public CreatePluginFamilyExpression <TPluginType> OnCreationForAll(string description,
Action <TPluginType> handler, Func <Instance, bool> filter = null)
{
return(InterceptWith(InterceptorFactory.ForAction(description, handler), filter));
}
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 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;
using (BatchClient client = ClientUnitTestCommon.CreateDummyClient())
{
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());
}
}
