public NodeFileOperationParameters(BatchAccountContext context, string jobId, string taskId, string poolId, string computeNodeId, string nodeFileName, PSNodeFile nodeFile, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { PSNodeFileType? nodeFileType = null; if (nodeFile != null) { nodeFileType = PSNodeFileType.PSNodeFileInstance; } else if (!string.IsNullOrWhiteSpace(nodeFileName)) { if (!string.IsNullOrWhiteSpace(jobId) && !string.IsNullOrWhiteSpace(taskId)) { nodeFileType = PSNodeFileType.Task; } else if (!string.IsNullOrWhiteSpace(poolId) && !string.IsNullOrWhiteSpace(computeNodeId)) { nodeFileType = PSNodeFileType.ComputeNode; } } if (nodeFileType == null) { throw new ArgumentException(Resources.NoNodeFile); } this.NodeFileType = nodeFileType.Value; this.JobId = jobId; this.TaskId = taskId; this.PoolId = poolId; this.ComputeNodeId = computeNodeId; this.NodeFileName = nodeFileName; this.NodeFile = nodeFile; }
public static void AssertBatchAccountContextsAreEqual(BatchAccountContext context1, BatchAccountContext context2) { if (context1 == null) { Assert.Null(context2); return; } if (context2 == null) { Assert.Null(context1); return; } Assert.Equal<string>(context1.AccountEndpoint, context2.AccountEndpoint); Assert.Equal<string>(context1.AccountName, context2.AccountName); Assert.Equal<string>(context1.Id, context2.Id); Assert.Equal<string>(context1.Location, context2.Location); Assert.Equal<string>(context1.PrimaryAccountKey, context2.PrimaryAccountKey); Assert.Equal<string>(context1.ResourceGroupName, context2.ResourceGroupName); Assert.Equal<string>(context1.SecondaryAccountKey, context2.SecondaryAccountKey); Assert.Equal<string>(context1.State, context2.State); Assert.Equal<string>(context1.Subscription, context2.Subscription); Assert.Equal<string>(context1.TagsTable, context2.TagsTable); Assert.Equal<string>(context1.TaskTenantUrl, context2.TaskTenantUrl); }
public NewTaskParameters(BatchAccountContext context, string jobId, PSCloudJob job, string taskId, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, jobId, job, additionalBehaviors) { if (string.IsNullOrWhiteSpace(taskId)) { throw new ArgumentNullException("taskId"); } this.TaskId = taskId; }
public ChangeOSVersionParameters(BatchAccountContext context, string poolId, PSCloudPool pool, string targetOSVersion, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, poolId, pool, additionalBehaviors) { if (string.IsNullOrWhiteSpace(targetOSVersion)) { throw new ArgumentNullException("targetOSVersion"); } this.TargetOSVersion = targetOSVersion; }
public NewWorkItemParameters(BatchAccountContext context, string workItemName, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(workItemName)) { throw new ArgumentNullException("poolName"); } this.WorkItemName = workItemName; }
public AutoScaleParameters(BatchAccountContext context, string poolId, PSCloudPool pool, string autoScaleFormula, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, poolId, pool, additionalBehaviors) { if (string.IsNullOrWhiteSpace(autoScaleFormula)) { throw new ArgumentNullException("autoScaleFormula"); } this.AutoScaleFormula = autoScaleFormula; }
public NewPoolParameters(BatchAccountContext context, string poolId, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(poolId)) { throw new ArgumentNullException("poolId"); } this.PoolId = poolId; }
public NewJobScheduleParameters(BatchAccountContext context, string jobScheduleId, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(jobScheduleId)) { throw new ArgumentNullException("jobScheduleId"); } this.JobScheduleId = jobScheduleId; }
public NewBulkTaskParameters(BatchAccountContext context, string jobId, PSCloudJob job, PSCloudTask[] tasks, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, jobId, job, additionalBehaviors) { if (tasks == null) { throw new ArgumentNullException("taskCollection"); } this.Tasks = tasks; }
protected BatchClientParametersBase(BatchAccountContext context, IEnumerable<BatchClientBehavior> additionalBehaviors = null) { if (context == null) { throw new ArgumentNullException("context"); } this.Context = context; this.AdditionalBehaviors = additionalBehaviors; }
/// <summary> /// Gets all pools lifetime summary statistics /// </summary> /// <param name="context">The account to use.</param> /// <param name="additionBehaviors">Additional client behaviors to perform.</param> public PSPoolStatistics GetAllPoolsLifetimeStatistics(BatchAccountContext context, IEnumerable<BatchClientBehavior> additionBehaviors = null) { PoolOperations poolOperations = context.BatchOMClient.PoolOperations; WriteVerbose(string.Format(Resources.GetAllPoolsLifetimeStatistics)); PoolStatistics poolStatistics = poolOperations.GetAllPoolsLifetimeStatistics(additionBehaviors); PSPoolStatistics psPoolStatistics = new PSPoolStatistics(poolStatistics); return psPoolStatistics; }
public WorkItemOperationParameters(BatchAccountContext context, string workItemName, PSCloudWorkItem workItem, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(workItemName) && workItem == null) { throw new ArgumentNullException(Resources.NoWorkItem); } this.WorkItemName = workItemName; this.WorkItem = workItem; }
public NewCertificateParameters(BatchAccountContext context, string filePath, byte[] rawData, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(filePath) && rawData == null) { throw new ArgumentException(Resources.NoCertificateData); } this.FilePath = filePath; this.RawData = rawData; }
public PoolOperationParameters(BatchAccountContext context, string poolName, PSCloudPool pool, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(poolName) && pool == null) { throw new ArgumentNullException(Resources.NoPool); } this.PoolName = poolName; this.Pool = pool; }
public JobOperationParameters(BatchAccountContext context, string jobId, PSCloudJob job, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(jobId) && job == null) { throw new ArgumentNullException(Resources.NoJob); } this.JobId = jobId; this.Job = job; }
public DownloadRemoteDesktopProtocolFileOptions(BatchAccountContext context, string poolId, string computeNodeId, PSComputeNode computeNode, string destinationPath, Stream stream, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, poolId, computeNodeId, computeNode, additionalBehaviors) { if (string.IsNullOrWhiteSpace(destinationPath) && stream == null) { throw new ArgumentNullException(Resources.NoDownloadDestination); } this.DestinationPath = destinationPath; this.Stream = stream; }
public DownloadVMFileOptions(BatchAccountContext context, string poolName, string vmName, string vmFileName, PSVMFile vmFile, string destinationPath, Stream stream, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, poolName, vmName, vmFileName, vmFile, additionalBehaviors) { if (string.IsNullOrWhiteSpace(destinationPath) && stream == null) { throw new ArgumentNullException(Resources.NoDownloadDestination); } this.DestinationPath = destinationPath; this.Stream = stream; }
public RemoveComputeNodeParameters(BatchAccountContext context, string poolId, string[] computeNodeIds, PSComputeNode computeNode, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if ((string.IsNullOrWhiteSpace(poolId) || computeNodeIds == null) && computeNode == null) { throw new ArgumentNullException(Resources.NoComputeNode); } this.PoolId = poolId; this.ComputeNodeIds = computeNodeIds; this.ComputeNode = computeNode; }
public VMUserOperationParameters(BatchAccountContext context, string poolName, string vmName, string vmUserName, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(poolName) || string.IsNullOrWhiteSpace(vmName) || string.IsNullOrWhiteSpace(vmUserName)) { throw new ArgumentNullException(Resources.NoVMUser); } this.PoolName = poolName; this.VMName = vmName; this.VMUserName = vmUserName; }
public TaskOperationParameters(BatchAccountContext context, string jobId, string taskId, PSCloudTask task, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if ((string.IsNullOrWhiteSpace(jobId) || string.IsNullOrWhiteSpace(taskId)) && task == null) { throw new ArgumentNullException(Resources.NoTask); } this.JobId = jobId; this.TaskId = taskId; this.Task = task; }
public DownloadNodeFileOptions(BatchAccountContext context, string jobId, string taskId, string poolId, string computeNodeId, string nodeFileName, PSNodeFile nodeFile, string destinationPath, Stream stream, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, jobId, taskId, poolId, computeNodeId, nodeFileName, nodeFile, additionalBehaviors) { if (string.IsNullOrWhiteSpace(destinationPath) && stream == null) { throw new ArgumentNullException(Resources.NoDownloadDestination); } this.DestinationPath = destinationPath; this.Stream = stream; }
public ComputeNodeUserOperationParameters(BatchAccountContext context, string poolId, string computeNodeId, string computeNodeUserName, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(poolId) || string.IsNullOrWhiteSpace(computeNodeId) || string.IsNullOrWhiteSpace(computeNodeUserName)) { throw new ArgumentNullException(Resources.NoComputeNodeUser); } this.PoolId = poolId; this.ComputeNodeId = computeNodeId; this.ComputeNodeUserName = computeNodeUserName; }
public ScenarioTestContext(BatchAccountContext context) : base() { if (context == null) { throw new ArgumentNullException("context"); } // Only set the properties needed for interacting with the Batch service. this.AccountName = context.AccountName; this.PrimaryAccountKey = context.PrimaryAccountKey; this.SecondaryAccountKey = context.SecondaryAccountKey; this.TaskTenantUrl = context.TaskTenantUrl; }
public TaskFileOperationParameters(BatchAccountContext context, string workItemName, string jobName, string taskName, string taskFileName, PSTaskFile taskFile, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if ((string.IsNullOrWhiteSpace(workItemName) || string.IsNullOrWhiteSpace(jobName) || string.IsNullOrWhiteSpace(taskName) || string.IsNullOrWhiteSpace(taskFileName)) && taskFile == null) { throw new ArgumentNullException(Resources.NoTaskFile); } this.WorkItemName = workItemName; this.JobName = jobName; this.TaskName = taskName; this.TaskFileName = taskFileName; this.TaskFile = taskFile; }
public CertificateOperationParameters(BatchAccountContext context, string thumbprintAlgorithm, string thumbprint, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if (string.IsNullOrWhiteSpace(thumbprintAlgorithm)) { throw new ArgumentNullException("thumbprintAlgorithm"); } if (string.IsNullOrWhiteSpace(thumbprint)) { throw new ArgumentNullException("thumbprint"); } this.ThumbprintAlgorithm = thumbprintAlgorithm; this.Thumbprint = thumbprint; }
public ListNodeFileOptions(BatchAccountContext context, string jobId, string taskId, PSCloudTask task, string poolId, string computeNodeId, PSComputeNode computeNode, IEnumerable<BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { if ((!string.IsNullOrWhiteSpace(jobId) && !string.IsNullOrWhiteSpace(taskId)) || task != null) { this.NodeFileType = PSNodeFileType.Task; } else if ((!string.IsNullOrWhiteSpace(poolId) && !string.IsNullOrWhiteSpace(computeNodeId)) || computeNode != null) { this.NodeFileType = PSNodeFileType.ComputeNode; } else { throw new ArgumentException(Resources.NoNodeFileParent); } this.JobId = jobId; this.TaskId = taskId; this.Task = task; this.PoolId = poolId; this.ComputeNodeId = computeNodeId; this.ComputeNode = computeNode; }
/// <summary> /// Terminates the specified job schedule. /// </summary> /// <param name="context">The account to use.</param> /// <param name="jobScheduleId">The id of the job schedule to terminate.</param> /// <param name="additionBehaviors">Additional client behaviors to perform.</param> public void TerminateJobSchedule(BatchAccountContext context, string jobScheduleId, IEnumerable<BatchClientBehavior> additionBehaviors = null) { if (string.IsNullOrWhiteSpace(jobScheduleId)) { throw new ArgumentNullException("jobScheduleId"); } WriteVerbose(string.Format(Resources.TerminateJobSchedule, jobScheduleId)); JobScheduleOperations jobScheduleOperations = context.BatchOMClient.JobScheduleOperations; jobScheduleOperations.TerminateJobSchedule(jobScheduleId, additionBehaviors); }
public PoolResizeParameters(BatchAccountContext context, string poolId, PSCloudPool pool, IEnumerable <BatchClientBehavior> additionalBehaviors = null) : base(context, poolId, pool, additionalBehaviors) { }
public void NewBatchCertificateRequestBodyTest() { BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; X509Certificate2 cert = new X509Certificate2(BatchTestHelpers.TestCertificateFileName); string certDataBase64String = Convert.ToBase64String(cert.RawData); CertificateAddParameter requestParameters = null; // Don't go to the service on an Add Certificate call RequestInterceptor interceptor = new RequestInterceptor((baseRequest) => { CertificateAddBatchRequest request = (CertificateAddBatchRequest)baseRequest; request.ServiceRequestFunc = (cancellationToken) => { requestParameters = request.Parameters; var response = new AzureOperationHeaderResponse <CertificateAddHeaders>(); Task <AzureOperationHeaderResponse <CertificateAddHeaders> > task = Task.FromResult(response); return(task); }; }); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; // Verify that when just the raw data is specified, the request body matches expectations cmdlet.RawData = cert.RawData; cmdlet.ExecuteCmdlet(); Assert.Equal(CertificateFormat.Cer, requestParameters.CertificateFormat); Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm); Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant()); Assert.True(string.IsNullOrEmpty(requestParameters.Password)); Assert.Equal(certDataBase64String, requestParameters.Data); // Verify that when the raw data is specified with a password, the request body matches expectations cmdlet.RawData = cert.RawData; cmdlet.Password = BatchTestHelpers.TestCertificatePassword.ConvertToSecureString(); cmdlet.ExecuteCmdlet(); Assert.Equal(CertificateFormat.Pfx, requestParameters.CertificateFormat); Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm); Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant()); Assert.Equal(BatchTestHelpers.TestCertificatePassword, requestParameters.Password); Assert.Equal(certDataBase64String, requestParameters.Data); // Verify that when just a file path is specified, the request body matches expectations cmdlet.RawData = null; cmdlet.Password = null; cmdlet.FilePath = BatchTestHelpers.TestCertificateFileName; cmdlet.ExecuteCmdlet(); Assert.Equal(CertificateFormat.Cer, requestParameters.CertificateFormat); Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm); Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant()); Assert.True(string.IsNullOrEmpty(requestParameters.Password)); Assert.Equal(certDataBase64String, requestParameters.Data); // Verify that when a file path is specified with a password, the request body matches expectations cmdlet.Password = BatchTestHelpers.TestCertificatePassword.ConvertToSecureString(); cmdlet.ExecuteCmdlet(); Assert.Equal(CertificateFormat.Pfx, requestParameters.CertificateFormat); Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm); Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant()); Assert.Equal(BatchTestHelpers.TestCertificatePassword, requestParameters.Password); Assert.Equal(certDataBase64String, requestParameters.Data); }
/// <summary> /// Commits changes to a PSCloudJobSchedule object to the Batch Service. /// </summary> /// <param name="context">The account to use.</param> /// <param name="jobSchedule">The PSCloudJobSchedule object representing the job schedule to update.</param> /// <param name="additionBehaviors">Additional client behaviors to perform.</param> public void UpdateJobSchedule(BatchAccountContext context, PSCloudJobSchedule jobSchedule, IEnumerable<BatchClientBehavior> additionBehaviors = null) { if (jobSchedule == null) { throw new ArgumentNullException("jobSchedule"); } WriteVerbose(string.Format(Resources.UpdatingJobSchedule, jobSchedule.Id)); Utils.Utils.BoundJobScheduleSyncCollections(jobSchedule); jobSchedule.omObject.Commit(additionBehaviors); }
public void SetBatchPoolParametersGetPassedToRequestTest() { BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; cmdlet.Pool = new PSCloudPool(BatchTestHelpers.CreateFakeBoundPool(context)); // Update the pool cmdlet.Pool.StartTask = new PSStartTask("cmd /c echo start task"); cmdlet.Pool.CertificateReferences = new List <PSCertificateReference>() { new PSCertificateReference() { StoreLocation = Azure.Batch.Common.CertStoreLocation.LocalMachine, Thumbprint = "thumbprint", ThumbprintAlgorithm = "sha1", StoreName = "My", Visibility = Azure.Batch.Common.CertificateVisibility.StartTask } }; cmdlet.Pool.ApplicationPackageReferences = new List <PSApplicationPackageReference>() { new PSApplicationPackageReference() { ApplicationId = "myApp", Version = "1.0" } }; cmdlet.Pool.Metadata = new Dictionary <string, string> { { "meta1", "value1" } }; PoolUpdatePropertiesParameter requestParameters = null; // Store the request parameters RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < PoolUpdatePropertiesParameter, PoolUpdatePropertiesOptions, AzureOperationHeaderResponse <PoolUpdatePropertiesHeaders> >(requestAction: (r) => { requestParameters = r.Parameters; }); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; cmdlet.ExecuteCmdlet(); // Verify the request parameters match the cmdlet parameters Assert.Equal(cmdlet.Pool.StartTask.CommandLine, requestParameters.StartTask.CommandLine); Assert.Equal(cmdlet.Pool.CertificateReferences.Count, requestParameters.CertificateReferences.Count); Assert.Equal(cmdlet.Pool.CertificateReferences[0].StoreName, requestParameters.CertificateReferences[0].StoreName); Assert.Equal(cmdlet.Pool.CertificateReferences[0].Thumbprint, requestParameters.CertificateReferences[0].Thumbprint); Assert.Equal(cmdlet.Pool.CertificateReferences[0].ThumbprintAlgorithm, requestParameters.CertificateReferences[0].ThumbprintAlgorithm); Assert.Equal(cmdlet.Pool.ApplicationPackageReferences.Count, requestParameters.ApplicationPackageReferences.Count); Assert.Equal(cmdlet.Pool.ApplicationPackageReferences[0].ApplicationId, requestParameters.ApplicationPackageReferences[0].ApplicationId); Assert.Equal(cmdlet.Pool.ApplicationPackageReferences[0].Version, requestParameters.ApplicationPackageReferences[0].Version); Assert.Equal(cmdlet.Pool.Metadata.Count, requestParameters.Metadata.Count); Assert.Contains( requestParameters.Metadata, metadata => metadata.Name == "meta1" && metadata.Value == cmdlet.Pool.Metadata["meta1"].ToString()); }
public void SetBatchJobScheduleParametersGetPassedToRequestTest() { BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; cmdlet.JobSchedule = new PSCloudJobSchedule(BatchTestHelpers.CreateFakeBoundJobSchedule(context)); // Make changes to the job schedule PSJobSpecification jobSpec = new PSJobSpecification() { DisplayName = "job display name", CommonEnvironmentSettings = new Dictionary <string, string> { { "common1", "val1" }, { "common2", "val2" } }, JobManagerTask = new PSJobManagerTask("job manager", "cmd /c echo job manager"), JobPreparationTask = new PSJobPreparationTask("cmd /c echo job prep"), JobReleaseTask = new PSJobReleaseTask("cmd /c echo job release"), PoolInformation = new PSPoolInformation() { PoolId = "myPool" } }; cmdlet.JobSchedule.JobSpecification = jobSpec; PSSchedule schedule = new PSSchedule() { DoNotRunAfter = DateTime.Now.AddYears(1), DoNotRunUntil = DateTime.Now.AddDays(1), RecurrenceInterval = TimeSpan.FromDays(1), StartWindow = TimeSpan.FromHours(1) }; cmdlet.JobSchedule.Schedule = schedule; cmdlet.JobSchedule.Metadata = new Dictionary <string, string> { { "metadata1", "value1" } }; // Store the request parameters JobScheduleUpdateParameter requestParameters = null; RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < JobScheduleUpdateParameter, JobScheduleUpdateOptions, AzureOperationHeaderResponse <JobScheduleUpdateHeaders> >(requestAction: (r) => { requestParameters = r.Parameters; }); cmdlet.AdditionalBehaviors = new BatchClientBehavior[] { interceptor }; cmdlet.ExecuteCmdlet(); // Verify that the request parameters contain the updated properties Assert.Equal(jobSpec.CommonEnvironmentSettings.Count, requestParameters.JobSpecification.CommonEnvironmentSettings.Count); Assert.Contains( requestParameters.JobSpecification.CommonEnvironmentSettings, setting => setting.Name == "common1" && setting.Value == jobSpec.CommonEnvironmentSettings["common1"].ToString()); Assert.Contains( requestParameters.JobSpecification.CommonEnvironmentSettings, setting => setting.Name == "common2" && setting.Value == jobSpec.CommonEnvironmentSettings["common2"].ToString()); Assert.Equal(jobSpec.JobManagerTask.Id, requestParameters.JobSpecification.JobManagerTask.Id); Assert.Equal(jobSpec.JobPreparationTask.CommandLine, requestParameters.JobSpecification.JobPreparationTask.CommandLine); Assert.Equal(jobSpec.JobReleaseTask.CommandLine, requestParameters.JobSpecification.JobReleaseTask.CommandLine); Assert.Equal(jobSpec.PoolInformation.PoolId, requestParameters.JobSpecification.PoolInfo.PoolId); Assert.Equal(schedule.DoNotRunAfter, requestParameters.Schedule.DoNotRunAfter); Assert.Equal(schedule.DoNotRunUntil, requestParameters.Schedule.DoNotRunUntil); Assert.Equal(schedule.RecurrenceInterval, requestParameters.Schedule.RecurrenceInterval); Assert.Equal(schedule.StartWindow, requestParameters.Schedule.StartWindow); Assert.Equal(cmdlet.JobSchedule.Metadata.Count, requestParameters.Metadata.Count); Assert.Contains( requestParameters.Metadata, metadata => metadata.Name == "metadata1" && metadata.Value == cmdlet.JobSchedule.Metadata["metadata1"].ToString()); }
public void WhenGetBatchPoolNodeCountsCommandIsCalledWithoutFilter_ShouldReturnAllPools() { // Setup cmdlet to get a pool by id BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; var poolNodeCounts1 = new ProxyModels.PoolNodeCounts() { PoolId = "Pool1", Dedicated = new ProxyModels.NodeCounts( creating: 1, idle: 2, offline: 3, preempted: 4, rebooting: 5, reimaging: 6, running: 7, starting: 8, startTaskFailed: 9, leavingPool: 10, unknown: 11, unusable: 12, waitingForStartTask: 13, total: 91), // Total LowPriority = new ProxyModels.NodeCounts( creating: 1, idle: 2, offline: 3, preempted: 4, rebooting: 5, reimaging: 6, running: 7, starting: 8, startTaskFailed: 9, leavingPool: 10, unknown: 11, unusable: 12, waitingForStartTask: 13, total: 91), // Total }; var poolNodeCounts2 = new ProxyModels.PoolNodeCounts() { PoolId = "Pool2", Dedicated = new ProxyModels.NodeCounts( creating: 11, idle: 12, offline: 13, preempted: 14, rebooting: 15, reimaging: 16, running: 17, starting: 18, startTaskFailed: 19, leavingPool: 20, unknown: 21, unusable: 22, waitingForStartTask: 23, total: 221), // Total LowPriority = new ProxyModels.NodeCounts( creating: 11, idle: 12, offline: 13, preempted: 14, rebooting: 15, reimaging: 16, running: 17, starting: 18, startTaskFailed: 19, leavingPool: 20, unknown: 21, unusable: 22, waitingForStartTask: 23, total: 221), // Total }; // Simulate node state counts for two pools are returned var poolsNodeCounts = new List <ProxyModels.PoolNodeCounts>() { poolNodeCounts1, poolNodeCounts2 }; // Build a PoolNodeCounts instead of querying the service on a Get PoolNodeCounts call AzureOperationResponse <IPage <ProxyModels.PoolNodeCounts>, ProxyModels.AccountListPoolNodeCountsHeaders> response = BatchTestHelpers.CreatePoolNodeCountsGetResponse(poolsNodeCounts); RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < ProxyModels.AccountListPoolNodeCountsOptions, AzureOperationResponse <IPage <ProxyModels.PoolNodeCounts>, ProxyModels.AccountListPoolNodeCountsHeaders> >(response); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; List <PSPoolNodeCounts> psPoolsNodeCounts = new List <PSPoolNodeCounts>(); commandRuntimeMock.Setup(r => r.WriteObject(It.IsAny <PSPoolNodeCounts>())) .Callback <object>(p => psPoolsNodeCounts.Add((PSPoolNodeCounts)p)); cmdlet.ExecuteCmdlet(); var psPoolNodeCounts1 = psPoolsNodeCounts.FirstOrDefault(c => c.PoolId == "Pool1"); var psPoolNodeCounts2 = psPoolsNodeCounts.FirstOrDefault(c => c.PoolId == "Pool2"); Assert.NotNull(psPoolNodeCounts1); Assert.NotNull(psPoolNodeCounts2); var comparer = new PoolNodeCountsObjectComparer(); Assert.True(comparer.AreEqual(poolNodeCounts1, psPoolNodeCounts1)); Assert.True(comparer.AreEqual(poolNodeCounts2, psPoolNodeCounts2)); }
public void WhenGettingATaskFromTheService_ExitConditionsAreMapped() { BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; cmdlet.Id = "task-1"; cmdlet.JobId = "job-1"; cmdlet.Filter = null; // Build a CloudTask instead of querying the service on a Get CloudTask call ProxyModels.ExitOptions none = new ProxyModels.ExitOptions { JobAction = ProxyModels.JobAction.None }; ProxyModels.ExitOptions terminate = new ProxyModels.ExitOptions { JobAction = ProxyModels.JobAction.Terminate }; ProxyModels.CloudTask cloudTask = new ProxyModels.CloudTask { Id = "task-1", ExitConditions = new ProxyModels.ExitConditions { ExitCodeRanges = new[] { new ProxyModels.ExitCodeRangeMapping(2, 5, none) }, ExitCodes = new[] { new ProxyModels.ExitCodeMapping(4, terminate) }, PreProcessingError = terminate, FileUploadError = none, DefaultProperty = none, } }; AzureOperationResponse <ProxyModels.CloudTask, ProxyModels.TaskGetHeaders> response = BatchTestHelpers.CreateCloudTaskGetResponse(cloudTask); RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor <ProxyModels.TaskGetOptions, AzureOperationResponse <ProxyModels.CloudTask, ProxyModels.TaskGetHeaders> >(response); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; // Setup the cmdlet to write pipeline output to a list that can be examined later var pipeline = new List <PSCloudTask>(); commandRuntimeMock.Setup(r => r.WriteObject(It.IsAny <PSCloudTask>())).Callback <object>(t => pipeline.Add((PSCloudTask)t)); cmdlet.ExecuteCmdlet(); // Verify that the cmdlet wrote the task returned from the OM to the pipeline Assert.Equal(1, pipeline.Count); Assert.Equal(cmdlet.Id, pipeline[0].Id); PSExitConditions psExitConditions = pipeline[0].ExitConditions; Assert.Equal(psExitConditions.Default.JobAction, JobAction.None); Assert.Equal(psExitConditions.ExitCodeRanges.First().ExitOptions.JobAction, JobAction.None); Assert.Equal(psExitConditions.PreProcessingError.JobAction, JobAction.Terminate); Assert.Equal(psExitConditions.FileUploadError.JobAction, JobAction.None); Assert.Equal(4, psExitConditions.ExitCodes.First().Code); Assert.Equal(JobAction.Terminate, psExitConditions.ExitCodes.First().ExitOptions.JobAction); Assert.Equal(2, psExitConditions.ExitCodeRanges.First().Start); Assert.Equal(5, psExitConditions.ExitCodeRanges.First().End); Assert.Equal(JobAction.None, psExitConditions.ExitCodeRanges.First().ExitOptions.JobAction); }
/// <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 ListTaskOptions(BatchAccountContext context, string jobId, PSCloudJob job, IEnumerable <BatchClientBehavior> additionalBehaviors = null) : base(context, jobId, job, additionalBehaviors) { }
/// <summary> /// Deletes a job used in a Scenario test. /// </summary> public static void DeleteJob(BatchController controller, BatchAccountContext context, string jobId) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); client.DeleteJob(context, jobId); }
/// <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(); } }
public 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 { omObject = new Azure.Batch.ExitOptions { JobAction = Azure.Batch.Common.JobAction.None } }; var terminate = new PSExitOptions { omObject = new Azure.Batch.ExitOptions { JobAction = Azure.Batch.Common.JobAction.Terminate } }; cmdlet.ExitConditions = new PSExitConditions { ExitCodes = new List <PSExitCodeMapping> { new PSExitCodeMapping(0, none) }, SchedulingError = terminate, ExitCodeRanges = new List <PSExitCodeRangeMapping> { new PSExitCodeRangeMapping(1, 5, terminate) }, 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.JobAction.Terminate, exitConditions.ExitCodeRanges.First().ExitOptions.JobAction); Assert.Equal(ProxyModels.JobAction.None, exitConditions.ExitCodes.First().ExitOptions.JobAction); Assert.Equal(ProxyModels.JobAction.Terminate, exitConditions.SchedulingError.JobAction); Assert.Equal(ProxyModels.JobAction.None, exitConditions.DefaultProperty.JobAction); }
public void NewBatchJobPoolUserAccountsGetPassedToRequest() { BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; cmdlet.Id = "testJob"; PSUserAccount adminUser = new PSUserAccount("admin", "password1", Azure.Batch.Common.ElevationLevel.Admin); PSUserAccount nonAdminUser = new PSUserAccount("user2", "password2", Azure.Batch.Common.ElevationLevel.NonAdmin); PSUserAccount sshUser = new PSUserAccount("user3", "password3", Azure.Batch.Common.ElevationLevel.Admin, new PSLinuxUserConfiguration(uid: 1, gid: 2, sshPrivateKey: "my ssh key")); cmdlet.PoolInformation = new PSPoolInformation { AutoPoolSpecification = new PSAutoPoolSpecification { AutoPoolIdPrefix = "prefix", PoolLifetimeOption = Azure.Batch.Common.PoolLifetimeOption.Job, PoolSpecification = new PSPoolSpecification { CloudServiceConfiguration = new PSCloudServiceConfiguration("4", "*"), UserAccounts = new List <PSUserAccount>() { adminUser, nonAdminUser, sshUser } } } }; JobAddParameter requestParameters = null; // Store the request parameters RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < JobAddParameter, JobAddOptions, AzureOperationHeaderResponse <JobAddHeaders> >(requestAction: (r) => { requestParameters = r.Parameters; }); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; cmdlet.ExecuteCmdlet(); // Verify the request parameters match the cmdlet parameters Assert.Equal(3, cmdlet.PoolInformation.AutoPoolSpecification.PoolSpecification.UserAccounts.Count); Assert.Equal(adminUser.Name, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[0].Name); Assert.Equal(adminUser.Password, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[0].Password); Assert.Equal(adminUser.ElevationLevel.ToString().ToLowerInvariant(), requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[0].ElevationLevel.ToString().ToLowerInvariant()); Assert.Equal(nonAdminUser.Name, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[1].Name); Assert.Equal(nonAdminUser.Password, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[1].Password); Assert.Equal(nonAdminUser.ElevationLevel.ToString().ToLowerInvariant(), requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[1].ElevationLevel.ToString().ToLowerInvariant()); Assert.Equal(sshUser.Name, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[2].Name); Assert.Equal(sshUser.Password, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[2].Password); Assert.Equal(sshUser.ElevationLevel.ToString().ToLowerInvariant(), requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[2].ElevationLevel.ToString().ToLowerInvariant()); Assert.Equal(sshUser.LinuxUserConfiguration.Uid, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[2].LinuxUserConfiguration.Uid); Assert.Equal(sshUser.LinuxUserConfiguration.Gid, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[2].LinuxUserConfiguration.Gid); Assert.Equal(sshUser.LinuxUserConfiguration.SshPrivateKey, requestParameters.PoolInfo.AutoPoolSpecification.Pool.UserAccounts[2].LinuxUserConfiguration.SshPrivateKey); }
public void WhenPSNodeCountsFormatObjectIsCalled_ShouldSerlializeNodeCountsToString() { const int creating = 1; const int idle = 2; const int offline = 3; const int preempted = 4; const int rebooting = 5; const int reimaging = 6; const int running = 7; const int starting = 8; const int startTaskFailed = 9; const int leavingPool = 10; const int unknown = 11; const int unusable = 12; const int waitingForStartTask = 13; const int total = 91; var poolNodeCounts = new ProxyModels.PoolNodeCounts() { PoolId = "Pool1", // all non-zero properties Dedicated = new ProxyModels.NodeCounts( creating: creating, idle: idle, offline: offline, preempted: preempted, rebooting: rebooting, reimaging: reimaging, running: running, starting: starting, startTaskFailed: startTaskFailed, leavingPool: leavingPool, unknown: unknown, unusable: unusable, waitingForStartTask: waitingForStartTask, total: total), // Total // all zero properties LowPriority = new ProxyModels.NodeCounts( creating: 0, idle: 0, offline: 0, preempted: 0, rebooting: 0, reimaging: 0, running: 0, starting: 0, startTaskFailed: 0, leavingPool: 0, unknown: 0, unusable: 0, waitingForStartTask: 0, total: 0), // Total }; BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; // Build a PoolNodeCounts instead of querying the service on a Get PoolNodeCounts call AzureOperationResponse <IPage <ProxyModels.PoolNodeCounts>, ProxyModels.AccountListPoolNodeCountsHeaders> response = BatchTestHelpers.CreatePoolNodeCountsGetResponse(new [] { poolNodeCounts }); RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < ProxyModels.AccountListPoolNodeCountsOptions, AzureOperationResponse <IPage <ProxyModels.PoolNodeCounts>, ProxyModels.AccountListPoolNodeCountsHeaders> >(response); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; List <PSPoolNodeCounts> psPoolsNodeCounts = new List <PSPoolNodeCounts>(); commandRuntimeMock.Setup(r => r.WriteObject(It.IsAny <PSPoolNodeCounts>())) .Callback <object>(p => psPoolsNodeCounts.Add((PSPoolNodeCounts)p)); cmdlet.ExecuteCmdlet(); var str = PSNodeCounts.FormatObject(psPoolsNodeCounts[0].Dedicated); const string segmentFormat = "{0}: {1}"; Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Creating), creating), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Idle), idle), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Offline), offline), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Preempted), preempted), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Rebooting), rebooting), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Reimaging), reimaging), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Running), running), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Starting), starting), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.StartTaskFailed), startTaskFailed), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.LeavingPool), leavingPool), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Unknown), unknown), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Unusable), unusable), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.WaitingForStartTask), waitingForStartTask), str); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Total), total), str); Assert.EndsWith(string.Format(segmentFormat, nameof(PSNodeCounts.Total), total), str); str = PSNodeCounts.FormatObject(psPoolsNodeCounts[0].LowPriority); Assert.Contains(string.Format(segmentFormat, nameof(PSNodeCounts.Total), 0), str); }
public ReimageComputeNodeParameters(BatchAccountContext context, string poolId, string computeNodeId, PSComputeNode computeNode, IEnumerable <BatchClientBehavior> additionalBehaviors = null) : base(context, poolId, computeNodeId, computeNode, additionalBehaviors) { }
public void NewBatchPoolParametersGetPassedToRequestTest() { BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; cmdlet.Id = "testPool"; cmdlet.ApplicationLicenses = new List <string>() { "foo", "bar" }; cmdlet.CertificateReferences = new PSCertificateReference[] { new PSCertificateReference() { StoreLocation = Azure.Batch.Common.CertStoreLocation.LocalMachine, Thumbprint = "thumbprint", ThumbprintAlgorithm = "sha1", StoreName = "My", Visibility = Azure.Batch.Common.CertificateVisibility.StartTask } }; cmdlet.CloudServiceConfiguration = new PSCloudServiceConfiguration("4", "*"); cmdlet.DisplayName = "display name"; cmdlet.InterComputeNodeCommunicationEnabled = true; cmdlet.MaxTasksPerComputeNode = 4; cmdlet.Metadata = new Dictionary <string, string>(); cmdlet.Metadata.Add("meta1", "value1"); cmdlet.ResizeTimeout = TimeSpan.FromMinutes(20); cmdlet.StartTask = new PSStartTask("cmd /c echo start task"); cmdlet.TargetDedicatedComputeNodes = 3; cmdlet.TargetLowPriorityComputeNodes = 2; cmdlet.TaskSchedulingPolicy = new PSTaskSchedulingPolicy(Azure.Batch.Common.ComputeNodeFillType.Spread); cmdlet.VirtualMachineConfiguration = new PSVirtualMachineConfiguration(new PSImageReference("offer", "publisher", "sku"), "node agent"); cmdlet.VirtualMachineSize = "small"; cmdlet.MountConfiguration = new[] { new PSMountConfiguration(new PSAzureBlobFileSystemConfiguration("foo", "bar", "baz", AzureStorageAuthenticationKey.FromAccountKey("abc"))) }; PoolAddParameter requestParameters = null; // Store the request parameters RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < PoolAddParameter, PoolAddOptions, AzureOperationHeaderResponse <PoolAddHeaders> >(requestAction: (r) => { requestParameters = r.Parameters; }); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; commandRuntimeMock.Setup(cr => cr.ShouldProcess(It.IsAny <string>())).Returns(true); cmdlet.ExecuteCmdlet(); // Verify the request parameters match the cmdlet parameters Assert.Equal(cmdlet.ApplicationLicenses[0], requestParameters.ApplicationLicenses[0]); Assert.Equal(cmdlet.ApplicationLicenses[1], requestParameters.ApplicationLicenses[1]); Assert.Equal(cmdlet.CertificateReferences.Length, requestParameters.CertificateReferences.Count); Assert.Equal(cmdlet.CertificateReferences[0].StoreName, requestParameters.CertificateReferences[0].StoreName); Assert.Equal(cmdlet.CertificateReferences[0].Thumbprint, requestParameters.CertificateReferences[0].Thumbprint); Assert.Equal(cmdlet.CertificateReferences[0].ThumbprintAlgorithm, requestParameters.CertificateReferences[0].ThumbprintAlgorithm); Assert.Equal(cmdlet.CloudServiceConfiguration.OSFamily, requestParameters.CloudServiceConfiguration.OsFamily); Assert.Equal(cmdlet.CloudServiceConfiguration.OSVersion, requestParameters.CloudServiceConfiguration.OsVersion); Assert.Equal(cmdlet.DisplayName, requestParameters.DisplayName); Assert.Equal(cmdlet.InterComputeNodeCommunicationEnabled, requestParameters.EnableInterNodeCommunication); Assert.Equal(cmdlet.MaxTasksPerComputeNode, requestParameters.MaxTasksPerNode); Assert.Equal(cmdlet.Metadata.Count, requestParameters.Metadata.Count); Assert.Equal(cmdlet.Metadata["meta1"], requestParameters.Metadata[0].Value); Assert.Equal(cmdlet.ResizeTimeout, requestParameters.ResizeTimeout); Assert.Equal(cmdlet.StartTask.CommandLine, requestParameters.StartTask.CommandLine); Assert.Equal(cmdlet.TargetDedicatedComputeNodes, requestParameters.TargetDedicatedNodes); Assert.Equal(cmdlet.TargetLowPriorityComputeNodes, requestParameters.TargetLowPriorityNodes); Assert.Equal(cmdlet.TaskSchedulingPolicy.ComputeNodeFillType.ToString(), requestParameters.TaskSchedulingPolicy.NodeFillType.ToString()); Assert.Equal(cmdlet.VirtualMachineConfiguration.NodeAgentSkuId, requestParameters.VirtualMachineConfiguration.NodeAgentSKUId); Assert.Equal(cmdlet.VirtualMachineConfiguration.ImageReference.Publisher, requestParameters.VirtualMachineConfiguration.ImageReference.Publisher); Assert.Equal(cmdlet.VirtualMachineConfiguration.ImageReference.Offer, requestParameters.VirtualMachineConfiguration.ImageReference.Offer); Assert.Equal(cmdlet.VirtualMachineConfiguration.ImageReference.Sku, requestParameters.VirtualMachineConfiguration.ImageReference.Sku); Assert.Equal(cmdlet.VirtualMachineSize, requestParameters.VmSize); Assert.Equal(cmdlet.MountConfiguration[0].AzureBlobFileSystemConfiguration.AccountName, requestParameters.MountConfiguration[0].AzureBlobFileSystemConfiguration.AccountName); Assert.Equal(cmdlet.MountConfiguration[0].AzureBlobFileSystemConfiguration.AccountKey, requestParameters.MountConfiguration[0].AzureBlobFileSystemConfiguration.AccountKey); Assert.Equal(cmdlet.MountConfiguration[0].AzureBlobFileSystemConfiguration.ContainerName, requestParameters.MountConfiguration[0].AzureBlobFileSystemConfiguration.ContainerName); Assert.Equal(cmdlet.MountConfiguration[0].AzureBlobFileSystemConfiguration.RelativeMountPath, requestParameters.MountConfiguration[0].AzureBlobFileSystemConfiguration.RelativeMountPath); }
/// <summary> /// Uploads an application package to Storage /// </summary> public static AddApplicationPackageResult CreateApplicationPackage(BatchController controller, BatchAccountContext context, string applicationId, string version, string filePath) { AddApplicationPackageResult applicationPackage = null; if (HttpMockServer.Mode == HttpRecorderMode.Record) { applicationPackage = controller.BatchManagementClient.Application.AddApplicationPackage( context.ResourceGroupName, context.AccountName, applicationId, version); CloudBlockBlob blob = new CloudBlockBlob(new Uri(applicationPackage.StorageUrl)); blob.UploadFromFile(filePath, FileMode.Open); } return(applicationPackage); }
public ListTaskFileOptions(BatchAccountContext context, string workItemName, string jobName, string taskName, PSCloudTask task, IEnumerable <BatchClientBehavior> additionalBehaviors = null) : base(context, workItemName, jobName, taskName, task, additionalBehaviors) { }
/// <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); }
public void GetBatchJobPreparationAndReleaseTaskStatusTestMaxCountTest() { // Verify default max count Assert.Equal(Utils.Constants.DefaultMaxCount, cmdlet.MaxCount); // Setup cmdlet to list jobs without filters and a max count BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; cmdlet.Id = "test"; cmdlet.Filter = null; const int maxCount = 2; cmdlet.MaxCount = maxCount; const string poolId = "Test"; // Build some PrepAndReleaseTaskStatuses instead of querying the service on a List CloudJobs call var taskExecutionInformationList = new List <ProxyModels.JobPreparationAndReleaseTaskExecutionInformation>(); const int countReturned = 3; for (int i = 0; i < countReturned; i++) { var jpjrInfo = new ProxyModels.JobPreparationAndReleaseTaskExecutionInformation( poolId: poolId, nodeId: Guid.NewGuid().ToString(), jobPreparationTaskExecutionInfo: new ProxyModels.JobPreparationTaskExecutionInformation( retryCount: 0, state: ProxyModels.JobPreparationTaskState.Completed, startTime: DateTime.UtcNow), jobReleaseTaskExecutionInfo: new ProxyModels.JobReleaseTaskExecutionInformation( state: ProxyModels.JobReleaseTaskState.Completed, startTime: DateTime.UtcNow)); taskExecutionInformationList.Add(jpjrInfo); } var response = BatchTestHelpers.CreateJobPreparationAndReleaseTaskStatusListResponse(taskExecutionInformationList); RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < ProxyModels.JobListPreparationAndReleaseTaskStatusOptions, AzureOperationResponse <IPage <ProxyModels.JobPreparationAndReleaseTaskExecutionInformation>, ProxyModels.JobListPreparationAndReleaseTaskStatusHeaders> >(response); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; // Setup the cmdlet to write pipeline output to a list that can be examined later var pipeline = new List <PSJobPreparationAndReleaseTaskExecutionInformation>(); commandRuntimeMock.Setup(r => r.WriteObject(It.IsAny <PSJobPreparationAndReleaseTaskExecutionInformation>())) .Callback <object>(j => pipeline.Add((PSJobPreparationAndReleaseTaskExecutionInformation)j)); cmdlet.ExecuteCmdlet(); // Verify that the max count was respected Assert.Equal(maxCount, pipeline.Count); // Verify setting max count <= 0 doesn't return nothing cmdlet.MaxCount = -5; pipeline.Clear(); cmdlet.ExecuteCmdlet(); Assert.Equal(countReturned, pipeline.Count); }
public ListJobPreparationAndReleaseStatusOptions(BatchAccountContext context, IEnumerable <BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { }
/// <summary> /// Verifies that two BatchAccountContext objects are equal /// </summary> public static void AssertBatchAccountContextsAreEqual(BatchAccountContext context1, BatchAccountContext context2) { if (context1 == null) { Assert.Null(context2); return; } if (context2 == null) { Assert.Null(context1); return; } Assert.Equal <string>(context1.AccountEndpoint, context2.AccountEndpoint); Assert.Equal <string>(context1.AccountName, context2.AccountName); Assert.Equal <string>(context1.Id, context2.Id); Assert.Equal <string>(context1.Location, context2.Location); Assert.Equal <string>(context1.PrimaryAccountKey, context2.PrimaryAccountKey); Assert.Equal <string>(context1.ResourceGroupName, context2.ResourceGroupName); Assert.Equal <string>(context1.SecondaryAccountKey, context2.SecondaryAccountKey); Assert.Equal <string>(context1.State, context2.State); Assert.Equal <string>(context1.Subscription, context2.Subscription); Assert.Equal <string>(context1.TagsTable, context2.TagsTable); Assert.Equal <string>(context1.TaskTenantUrl, context2.TaskTenantUrl); }
/// <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); }
public void NewBatchJobScheduleParametersGetPassedToRequestTest() { BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); cmdlet.BatchContext = context; cmdlet.Id = "testJobSchedule"; cmdlet.DisplayName = "display name"; Models.PSJobSpecification jobSpec = new Models.PSJobSpecification() { DisplayName = "job display name", CommonEnvironmentSettings = new Dictionary <string, string> { { "common1", "val1" }, { "common2", "val2" } }, JobManagerTask = new Models.PSJobManagerTask("job manager", "cmd /c echo job manager"), JobPreparationTask = new Models.PSJobPreparationTask("cmd /c echo job prep"), JobReleaseTask = new Models.PSJobReleaseTask("cmd /c echo job release"), PoolInformation = new Models.PSPoolInformation() { PoolId = "myPool" } }; cmdlet.JobSpecification = jobSpec; Models.PSSchedule schedule = new Models.PSSchedule() { DoNotRunAfter = DateTime.Now.AddYears(1), DoNotRunUntil = DateTime.Now.AddDays(1), RecurrenceInterval = TimeSpan.FromDays(1), StartWindow = TimeSpan.FromHours(1) }; cmdlet.Schedule = schedule; cmdlet.Metadata = new Dictionary <string, string>(); cmdlet.Metadata.Add("meta1", "value1"); cmdlet.Metadata.Add("meta2", "value2"); JobScheduleAddParameter requestParameters = null; // Store the request parameters RequestInterceptor interceptor = BatchTestHelpers.CreateFakeServiceResponseInterceptor < JobScheduleAddParameter, JobScheduleAddOptions, AzureOperationHeaderResponse <JobScheduleAddHeaders> >(requestAction: (r) => { requestParameters = r.Parameters; }); cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor }; cmdlet.ExecuteCmdlet(); // Verify the request parameters match the cmdlet parameters Assert.Equal(cmdlet.DisplayName, requestParameters.DisplayName); Assert.Equal(jobSpec.CommonEnvironmentSettings.Count, requestParameters.JobSpecification.CommonEnvironmentSettings.Count); Assert.Contains( requestParameters.JobSpecification.CommonEnvironmentSettings, setting => setting.Name == "common1" && setting.Value == jobSpec.CommonEnvironmentSettings["common1"].ToString()); Assert.Contains( requestParameters.JobSpecification.CommonEnvironmentSettings, setting => setting.Name == "common2" && setting.Value == jobSpec.CommonEnvironmentSettings["common2"].ToString()); Assert.Equal(jobSpec.JobManagerTask.Id, requestParameters.JobSpecification.JobManagerTask.Id); Assert.Equal(jobSpec.JobPreparationTask.CommandLine, requestParameters.JobSpecification.JobPreparationTask.CommandLine); Assert.Equal(jobSpec.JobReleaseTask.CommandLine, requestParameters.JobSpecification.JobReleaseTask.CommandLine); Assert.Equal(jobSpec.PoolInformation.PoolId, requestParameters.JobSpecification.PoolInfo.PoolId); Assert.Equal(schedule.DoNotRunAfter, requestParameters.Schedule.DoNotRunAfter); Assert.Equal(schedule.DoNotRunUntil, requestParameters.Schedule.DoNotRunUntil); Assert.Equal(schedule.RecurrenceInterval, requestParameters.Schedule.RecurrenceInterval); Assert.Equal(schedule.StartWindow, requestParameters.Schedule.StartWindow); Assert.Equal(cmdlet.Metadata.Count, requestParameters.Metadata.Count); Assert.Equal(cmdlet.Metadata[requestParameters.Metadata[0].Name], requestParameters.Metadata[0].Value); Assert.Equal(cmdlet.Metadata[requestParameters.Metadata[1].Name], requestParameters.Metadata[1].Value); }
/// <summary> /// Deletes the specified job schedule. /// </summary> /// <param name="context">The account to use.</param> /// <param name="jobScheduleId">The id of the job schedule to delete.</param> /// <param name="additionBehaviors">Additional client behaviors to perform.</param> public void DeleteJobSchedule(BatchAccountContext context, string jobScheduleId, IEnumerable<BatchClientBehavior> additionBehaviors = null) { if (string.IsNullOrWhiteSpace(jobScheduleId)) { throw new ArgumentNullException("jobScheduleId"); } JobScheduleOperations jobScheduleOperations = context.BatchOMClient.JobScheduleOperations; jobScheduleOperations.DeleteJobSchedule(jobScheduleId, additionBehaviors); }
public void WhenStartBatchComputeNodeServiceLogUploadCommandIsCalledWithComputeNode_ShouldSucceed() { // First get a fake tvm BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys(); getComputeNodeCommand.BatchContext = context; getComputeNodeCommand.PoolId = "Pool1"; getComputeNodeCommand.Id = null; getComputeNodeCommand.Filter = null; AzureOperationResponse <IPage <ProxyModels.ComputeNode>, ProxyModels.ComputeNodeListHeaders> response1 = BatchTestHelpers.CreateComputeNodeListResponse(new[] { "tvm1" }); RequestInterceptor interceptor1 = BatchTestHelpers.CreateFakeServiceResponseInterceptor < ProxyModels.ComputeNodeListOptions, AzureOperationResponse <IPage <ProxyModels.ComputeNode>, ProxyModels.ComputeNodeListHeaders> >(response1); var computeNodes = new List <PSComputeNode>(); commandRuntimeMock.Setup(r => r.WriteObject(It.IsAny <PSComputeNode>())) .Callback <object>(c => computeNodes.Add((PSComputeNode)c)); getComputeNodeCommand.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor1 }; getComputeNodeCommand.ExecuteCmdlet(); // test StartBatchComputeNodeServiceLogUploadCommand startComputeNodeServiceLogUploadCommand.BatchContext = context; startComputeNodeServiceLogUploadCommand.ComputeNode = computeNodes[0]; startComputeNodeServiceLogUploadCommand.ContainerUrl = fakeUrl; var utcNow = DateTime.UtcNow; startComputeNodeServiceLogUploadCommand.StartTime = utcNow.AddDays(-1); startComputeNodeServiceLogUploadCommand.EndTime = utcNow; const int numberOfFilesUploaded = 2; const string virtualDirectoryName = "pool1/tvm"; AzureOperationResponse <ProxyModels.UploadBatchServiceLogsResult, ProxyModels.ComputeNodeUploadBatchServiceLogsHeaders> response2 = BatchTestHelpers.CreateComputeNodeServiceLogsAddResponse(numberOfFilesUploaded, virtualDirectoryName); RequestInterceptor interceptor2 = BatchTestHelpers.CreateFakeServiceResponseInterceptor < ProxyModels.ComputeNodeUploadBatchServiceLogsOptions, AzureOperationResponse <ProxyModels.UploadBatchServiceLogsResult, ProxyModels.ComputeNodeUploadBatchServiceLogsHeaders> >(response2); startComputeNodeServiceLogUploadCommand.AdditionalBehaviors = new List <BatchClientBehavior>() { interceptor2 }; // Setup the cmdlet to write pipeline output to a list that can be examined later PSStartComputeNodeServiceLogUploadResult result = null; commandRuntimeMock.Setup(r => r.WriteObject(It.IsAny <PSStartComputeNodeServiceLogUploadResult>())).Callback <object>(c => result = (PSStartComputeNodeServiceLogUploadResult)c); startComputeNodeServiceLogUploadCommand.ExecuteCmdlet(); Assert.NotNull(result); Assert.Equal(result.NumberOfFilesUploaded, numberOfFilesUploaded); Assert.Equal(result.VirtualDirectoryName, virtualDirectoryName); }
public ListJobScheduleOptions(BatchAccountContext context, IEnumerable <BatchClientBehavior> additionalBehaviors = null) : base(context, additionalBehaviors) { }
/// <summary> /// Deletes an application package used in a Scenario test. /// </summary> public static void DeleteApplicationPackage(BatchController controller, BatchAccountContext context, string applicationName, string version) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); client.DeleteApplicationPackage(context.ResourceGroupName, context.AccountName, applicationName, version); }