Create data models for convenience client calls per feedback

Author: jasper-schneider

src/ResourceManager/Batch/Commands.Batch.Test/Jobs/GetBatchJobCommandTests.cs

@@ -176,10 +176,6 @@ public void ListJobsMaxCountTest()
             // Verify default max count
             Assert.Equal(Microsoft.Azure.Commands.Batch.Utils.Constants.DefaultMaxCount, cmdlet.MaxCount);
 
-            // Verify setting max count <= 0
-            cmdlet.MaxCount = -5;
-            Assert.Equal(int.MaxValue, cmdlet.MaxCount);
-
             // Setup cmdlet to list Jobs without filters and a max count
             BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
             cmdlet.BatchContext = context;
@@ -214,6 +210,13 @@ public void ListJobsMaxCountTest()
 
             // 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(namesOfConstructedJobs.Length, pipeline.Count);
         }
     }
 }

src/ResourceManager/Batch/Commands.Batch.Test/Pools/GetBatchPoolCommandTests.cs

@@ -173,10 +173,6 @@ public void ListPoolsMaxCountTest()
             // Verify default max count
             Assert.Equal(Microsoft.Azure.Commands.Batch.Utils.Constants.DefaultMaxCount, cmdlet.MaxCount);
 
-            // Verify setting max count <= 0
-            cmdlet.MaxCount = -5;
-            Assert.Equal(int.MaxValue, cmdlet.MaxCount);
-
             // Setup cmdlet to list Pools without filters and a max count
             BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
             cmdlet.BatchContext = context;
@@ -210,6 +206,13 @@ public void ListPoolsMaxCountTest()
 
             // 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(namesOfConstructedPools.Length, pipeline.Count);
         }
     }
 }

src/ResourceManager/Batch/Commands.Batch.Test/ScenarioTests/ScenarioTestHelpers.cs

@@ -134,7 +134,16 @@ public static string WaitForRecentJob(BatchController controller, BatchAccountCo
             YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor();
             BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor };
             BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
-            PSCloudWorkItem workItem = client.ListWorkItems(context, workItemName, null, Constants.DefaultMaxCount, behaviors).First();
+
+            ListWorkItemOptions options = new ListWorkItemOptions()
+            {
+                Context = context,
+                WorkItemName = workItemName,
+                Filter = null,
+                MaxCount = Constants.DefaultMaxCount,
+                AdditionalBehaviors = behaviors
+            };
+            PSCloudWorkItem workItem = client.ListWorkItems(options).First();
 
             while (workItem.ExecutionInformation.RecentJob == null || string.Equals(workItem.ExecutionInformation.RecentJob.Name, previousJob, StringComparison.OrdinalIgnoreCase))
             {
@@ -143,7 +152,7 @@ public static string WaitForRecentJob(BatchController controller, BatchAccountCo
                     throw new TimeoutException("Timed out waiting for recent job");
                 }
                 Sleep(5000);
-                workItem = client.ListWorkItems(context, workItemName, null, Constants.DefaultMaxCount, behaviors).First();
+                workItem = client.ListWorkItems(options).First();
             }
             return workItem.ExecutionInformation.RecentJob.Name;
         }

src/ResourceManager/Batch/Commands.Batch.Test/Tasks/GetBatchTaskCommandTests.cs

@@ -179,10 +179,6 @@ public void ListTasksMaxCountTest()
             // Verify default max count
             Assert.Equal(Microsoft.Azure.Commands.Batch.Utils.Constants.DefaultMaxCount, cmdlet.MaxCount);
 
-            // Verify setting max count <= 0
-            cmdlet.MaxCount = -5;
-            Assert.Equal(int.MaxValue, cmdlet.MaxCount);
-
             // Setup cmdlet to list Tasks without filters and a max count
             BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
             cmdlet.BatchContext = context;
@@ -218,6 +214,13 @@ public void ListTasksMaxCountTest()
 
             // 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(namesOfConstructedTasks.Length, pipeline.Count);
         }
     }
 }

src/ResourceManager/Batch/Commands.Batch.Test/WorkItems/GetBatchWorkItemCommandTests.cs

@@ -173,10 +173,6 @@ public void ListWorkItemMaxCountTest()
             // Verify default max count
             Assert.Equal(Microsoft.Azure.Commands.Batch.Utils.Constants.DefaultMaxCount, cmdlet.MaxCount);
 
-            // Verify setting max count <= 0
-            cmdlet.MaxCount = -5;
-            Assert.Equal(int.MaxValue, cmdlet.MaxCount);
-
             // Setup cmdlet to list WorkItems without filters and a max count
             BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
             cmdlet.BatchContext = context;
@@ -210,6 +206,13 @@ public void ListWorkItemMaxCountTest()
 
             // 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(namesOfConstructedWorkItems.Length, pipeline.Count);
         }
 
     }

src/ResourceManager/Batch/Commands.Batch/Commands.Batch.csproj

@@ -152,6 +152,10 @@
     <Compile Include="Models\BatchClient.Pools.cs" />
     <Compile Include="Models\BatchClient.Tasks.cs" />
     <Compile Include="Models\BatchClient.WorkItems.cs" />
+    <Compile Include="Models\ListJobOptions.cs" />
+    <Compile Include="Models\ListPoolOptions.cs" />
+    <Compile Include="Models\ListTaskOptions.cs" />
+    <Compile Include="Models\ListWorkItemOptions.cs" />
     <Compile Include="Models\PSAffinitiyInformation.cs" />
     <Compile Include="Models\PSAsyncEnumerable.cs" />
     <Compile Include="Models\PSAutoPoolSpecification.cs" />

src/ResourceManager/Batch/Commands.Batch/Jobs/GetBatchJobCommand.cs

@@ -48,15 +48,26 @@ public class GetBatchJobCommand : BatchObjectModelCmdletBase
         public int MaxCount
         {
             get { return this.maxCount; }
-            set { this.maxCount = value <= 0 ? Int32.MaxValue : value; }
+            set { this.maxCount = value; }
         }
 
         public override void ExecuteCmdlet()
         {
+            ListJobOptions options = new ListJobOptions()
+            {
+                Context = this.BatchContext,
+                WorkItemName = this.WorkItemName,
+                JobName = this.Name,
+                WorkItem = this.WorkItem,
+                Filter = this.Filter,
+                MaxCount = this.MaxCount,
+                AdditionalBehaviors = this.AdditionalBehaviors
+            };
+
             // The enumerator will internally query the service in chunks. Using WriteObject with the enumerate flag will enumerate
             // the entire collection first and then write the items out one by one in a single group.  Using foreach, we can take 
             // advantage of the enumerator's behavior and write output to the pipeline in bursts.
-            foreach (PSCloudJob job in BatchClient.ListJobs(BatchContext, WorkItemName, WorkItem, Name, Filter, MaxCount, AdditionalBehaviors))
+            foreach (PSCloudJob job in BatchClient.ListJobs(options))
             {
                 WriteObject(job);
             }

src/ResourceManager/Batch/Commands.Batch/Models/BatchClient.Jobs.cs

@@ -26,53 +26,55 @@ public partial class BatchClient
         /// <summary>
         /// Lists the Jobs matching the specified filter options
         /// </summary>
-        /// <param name="context">The account details</param>
-        /// <param name="workItemName">The name of the WorkItem to query for Jobs</param>
-        /// <param name="workItem">The WorkItem to query for Jobs</param>
-        /// <param name="jobName">If specified, the single Job with this name will be returned</param>
-        /// <param name="filter">The OData filter to use when querying for Jobs</param>
-        /// <param name="maxCount">The maximum number of Jobs to return</param>
-        /// <param name="additionalBehaviors">Additional client behaviors to perform</param>
+        /// <param name="options">The options to use when querying for Jobs</param>
         /// <returns>The Jobs matching the specified filter options</returns>
-        public IEnumerable<PSCloudJob> ListJobs(BatchAccountContext context, string workItemName, PSCloudWorkItem workItem, string jobName,
-            string filter, int maxCount, IEnumerable<BatchClientBehavior> additionalBehaviors = null)
+        public IEnumerable<PSCloudJob> ListJobs(ListJobOptions options)
         {
-            if (string.IsNullOrEmpty(workItemName) && workItem == null)
+            if (options == null)
+            {
+                throw new ArgumentNullException("options");
+            }
+
+            if (string.IsNullOrEmpty(options.WorkItemName) && options.WorkItem == null)
             {
                 throw new ArgumentNullException(Resources.GBJ_NoWorkItem);    
             }
-            string wiName = workItem == null ? workItemName : workItem.Name;
+            string wiName = options.WorkItem == null ? options.WorkItemName : options.WorkItem.Name;
 
             // Get the single Job matching the specified name
-            if (!string.IsNullOrEmpty(jobName))
+            if (!string.IsNullOrEmpty(options.JobName))
             {
-                WriteVerbose(string.Format(Resources.GBJ_GetByName, jobName, wiName));
-                using (IWorkItemManager wiManager = context.BatchOMClient.OpenWorkItemManager())
+                WriteVerbose(string.Format(Resources.GBJ_GetByName, options.JobName, wiName));
+                using (IWorkItemManager wiManager = options.Context.BatchOMClient.OpenWorkItemManager())
                 {
-                    ICloudJob job = wiManager.GetJob(wiName, jobName, additionalBehaviors: additionalBehaviors);
+                    ICloudJob job = wiManager.GetJob(wiName, options.JobName, additionalBehaviors: options.AdditionalBehaviors);
                     PSCloudJob psJob = new PSCloudJob(job);
                     return new PSCloudJob[] { psJob };
                 }
             }
             // List Jobs using the specified filter
             else
             {
+                if (options.MaxCount <= 0)
+                {
+                    options.MaxCount = Int32.MaxValue;
+                }
                 ODATADetailLevel odata = null;
-                if (!string.IsNullOrEmpty(filter))
+                if (!string.IsNullOrEmpty(options.Filter))
                 {
-                    WriteVerbose(string.Format(Resources.GBJ_GetByOData, wiName, maxCount));
-                    odata = new ODATADetailLevel(filterClause: filter);
+                    WriteVerbose(string.Format(Resources.GBJ_GetByOData, wiName, options.MaxCount));
+                    odata = new ODATADetailLevel(filterClause: options.Filter);
                 }
                 else
                 {
-                    WriteVerbose(string.Format(Resources.GBJ_GetNoFilter, wiName, maxCount));
+                    WriteVerbose(string.Format(Resources.GBJ_GetNoFilter, wiName, options.MaxCount));
                 }
 
-                using (IWorkItemManager wiManager = context.BatchOMClient.OpenWorkItemManager())
+                using (IWorkItemManager wiManager = options.Context.BatchOMClient.OpenWorkItemManager())
                 {
-                    IEnumerableAsyncExtended<ICloudJob> jobs = wiManager.ListJobs(wiName, odata, additionalBehaviors);
+                    IEnumerableAsyncExtended<ICloudJob> jobs = wiManager.ListJobs(wiName, odata, options.AdditionalBehaviors);
                     Func<ICloudJob, PSCloudJob> mappingFunction = j => { return new PSCloudJob(j); };
-                    return new PSAsyncEnumerable<PSCloudJob, ICloudJob>(jobs, mappingFunction).Take(maxCount);           
+                    return new PSAsyncEnumerable<PSCloudJob, ICloudJob>(jobs, mappingFunction).Take(options.MaxCount);           
                 }             
             }
         }

src/ResourceManager/Batch/Commands.Batch/Models/BatchClient.Pools.cs

@@ -26,44 +26,48 @@ public partial class BatchClient
         /// <summary>
         /// Lists the Pools matching the specified filter options
         /// </summary>
-        /// <param name="context">The account details</param>
-        /// <param name="poolName">If specified, the single Pool with this name will be returned</param>
-        /// <param name="filter">The OData filter to use when querying for Pools</param>
-        /// <param name="maxCount">The maximum number of Pools to return</param>
-        /// <param name="additionalBehaviors">Additional client behaviors to perform</param>
+        /// <param name="options">The options to use when querying for Pools</param>
         /// <returns>The Pools matching the specified filter options</returns>
-        public IEnumerable<PSCloudPool> ListPools(BatchAccountContext context, string poolName, string filter, int maxCount,
-            IEnumerable<BatchClientBehavior> additionalBehaviors = null)
+        public IEnumerable<PSCloudPool> ListPools(ListPoolOptions options)
         {
+            if (options == null)
+            {
+                throw new ArgumentNullException("options");
+            }
+
             // Get the single Pool matching the specified name
-            if (!string.IsNullOrEmpty(poolName))
+            if (!string.IsNullOrEmpty(options.PoolName))
             {
-                WriteVerbose(string.Format(Resources.GBP_GetByName, poolName));
-                using (IPoolManager poolManager = context.BatchOMClient.OpenPoolManager())
+                WriteVerbose(string.Format(Resources.GBP_GetByName, options.PoolName));
+                using (IPoolManager poolManager = options.Context.BatchOMClient.OpenPoolManager())
                 {
-                    ICloudPool pool = poolManager.GetPool(poolName, additionalBehaviors: additionalBehaviors);
+                    ICloudPool pool = poolManager.GetPool(options.PoolName, additionalBehaviors: options.AdditionalBehaviors);
                     PSCloudPool psPool = new PSCloudPool(pool);
                     return new PSCloudPool[] { psPool };
                 }
             }
             // List Pools using the specified filter
             else
             {
+                if (options.MaxCount <= 0)
+                {
+                    options.MaxCount = Int32.MaxValue;
+                }
                 ODATADetailLevel odata = null;
-                if (!string.IsNullOrEmpty(filter))
+                if (!string.IsNullOrEmpty(options.Filter))
                 {
-                    WriteVerbose(string.Format(Resources.GBP_GetByOData, maxCount));
-                    odata = new ODATADetailLevel(filterClause: filter);
+                    WriteVerbose(string.Format(Resources.GBP_GetByOData, options.MaxCount));
+                    odata = new ODATADetailLevel(filterClause: options.Filter);
                 }
                 else
                 {
-                    WriteVerbose(string.Format(Resources.GBP_NoFilter, maxCount));
+                    WriteVerbose(string.Format(Resources.GBP_NoFilter, options.MaxCount));
                 }
-                using (IPoolManager poolManager = context.BatchOMClient.OpenPoolManager())
+                using (IPoolManager poolManager = options.Context.BatchOMClient.OpenPoolManager())
                 {
-                    IEnumerableAsyncExtended<ICloudPool> pools = poolManager.ListPools(odata, additionalBehaviors);
+                    IEnumerableAsyncExtended<ICloudPool> pools = poolManager.ListPools(odata, options.AdditionalBehaviors);
                     Func<ICloudPool, PSCloudPool> mappingFunction = p => { return new PSCloudPool(p); };
-                    return new PSAsyncEnumerable<PSCloudPool, ICloudPool>(pools, mappingFunction).Take(maxCount);
+                    return new PSAsyncEnumerable<PSCloudPool, ICloudPool>(pools, mappingFunction).Take(options.MaxCount);
                 }
             }
         }