C# ScenarioTests.ScenarioTestContext类代码示例

 public void TestCancelCertificateDelete()
 {
     BatchController controller = BatchController.NewInstance;
     BatchAccountContext context = null;
     string thumbprint = null;
     string poolId = "certPool";
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-TestCancelCertificateDelete '{0}' '{1}'", BatchTestHelpers.TestCertificateAlgorithm, thumbprint) }; },
         () =>
         {
             context = new ScenarioTestContext();
             thumbprint = ScenarioTestHelpers.AddTestCertificate(controller, context, BatchTestHelpers.TestCertificateFileName);
             CertificateReference certRef = new CertificateReference();
             certRef.StoreLocation = CertStoreLocation.CurrentUser;
             certRef.StoreName = "My";
             certRef.ThumbprintAlgorithm = BatchTestHelpers.TestCertificateAlgorithm;
             certRef.Thumbprint = thumbprint;
             certRef.Visibility = CertificateVisibility.Task;
             ScenarioTestHelpers.CreateTestPool(controller, context, poolId, 0, certRef);
             ScenarioTestHelpers.DeleteTestCertificate(controller, context, BatchTestHelpers.TestCertificateAlgorithm, thumbprint);
             ScenarioTestHelpers.WaitForCertificateToFailDeletion(controller, context, BatchTestHelpers.TestCertificateAlgorithm, thumbprint);
         },
         () =>
         {
             ScenarioTestHelpers.DeletePool(controller, context, poolId);
             ScenarioTestHelpers.DeleteTestCertificate(controller, context, BatchTestHelpers.TestCertificateAlgorithm, thumbprint);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

 public void TestListJobSchedulesByFilter()
 {
     BatchController controller = BatchController.NewInstance;
     string jobScheduleId1 = "testId1";
     string jobScheduleId2 = "testId2";
     string jobScheduleId3 = "thirdtestId";
     string jobSchedulePrefix = "testId";
     int matches = 2;
     BatchAccountContext context = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-ListJobSchedulesByFilter '{0}' '{1}'", jobSchedulePrefix, matches) }; },
         () =>
         {
             context = new ScenarioTestContext();
             ScenarioTestHelpers.CreateTestJobSchedule(controller, context, jobScheduleId1, null);
             ScenarioTestHelpers.CreateTestJobSchedule(controller, context, jobScheduleId2, null);
             ScenarioTestHelpers.CreateTestJobSchedule(controller, context, jobScheduleId3, null);
         },
         () =>
         {
             ScenarioTestHelpers.DeleteJobSchedule(controller, context, jobScheduleId1);
             ScenarioTestHelpers.DeleteJobSchedule(controller, context, jobScheduleId2);
             ScenarioTestHelpers.DeleteJobSchedule(controller, context, jobScheduleId3);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

 public void TestListCertificatesByFilter()
 {
     BatchController controller = BatchController.NewInstance;
     BatchAccountContext context = null;
     string state = "active";
     string thumbprint1 = null;
     string toDeleteThumbprint = null;
     int matchCount = 1;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-ListCertificatesByFilter '{0}' '{1}' '{2}'", state, toDeleteThumbprint, matchCount) }; },
         () =>
         {
             context = new ScenarioTestContext();
             thumbprint1 = ScenarioTestHelpers.AddTestCertificate(controller, context, BatchTestHelpers.TestCertificateFileName1);
             toDeleteThumbprint = ScenarioTestHelpers.AddTestCertificate(controller, context, BatchTestHelpers.TestCertificateFileName2);
         },
         () =>
         {
             ScenarioTestHelpers.DeleteTestCertificate(controller, context, BatchTestHelpers.TestCertificateAlgorithm, thumbprint1);
             // Other cert is deleted as the first part of the PowerShell test script, but we ensure it's gone.
             try
             {
                 ScenarioTestHelpers.DeleteTestCertificate(controller, context, BatchTestHelpers.TestCertificateAlgorithm, toDeleteThumbprint);
             }
             catch { }
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

        public void TestUpdateApplicationPackage()
        {
            string id = "updateApplicationPackage";

            BatchController controller = BatchController.NewInstance;
            BatchAccountContext context = null;
            controller.RunPsTestWorkflow(
                () =>
                {
                    return new string[]
                    {
                        string.Format(string.Format("Test-UpdateApplicationPackage '{0}' '{1}' '{2}'", id, version, filePath))
                    };
                },
                () =>
                {
                    context = new ScenarioTestContext();
                    ScenarioTestHelpers.CreateApplicationPackage(controller, context, id, version, filePath);
                },
                () =>
                {
                    ScenarioTestHelpers.DeleteApplicationPackage(controller, context, id, version);
                    ScenarioTestHelpers.DeleteApplication(controller, context, id);
                },
                TestUtilities.GetCallingClass(),
                TestUtilities.GetCurrentMethodName());
        }

 public void TestListPoolsByFilter()
 {
     BatchController controller = BatchController.NewInstance;
     string poolId1 = "testFilter1";
     string poolId2 = "testFilter2";
     string poolId3 = "thirdFilterTest";
     string poolPrefix = "testFilter";
     int matches = 2;
     BatchAccountContext context = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-ListPoolsByFilter '{0}' '{1}'", poolPrefix, matches) }; },
         () =>
         {
             context = new ScenarioTestContext();
             ScenarioTestHelpers.CreateTestPool(controller, context, poolId1, 0);
             ScenarioTestHelpers.CreateTestPool(controller, context, poolId2, 0);
             ScenarioTestHelpers.CreateTestPool(controller, context, poolId3, 0);
         },
         () =>
         {
             ScenarioTestHelpers.DeletePool(controller, context, poolId1);
             ScenarioTestHelpers.DeletePool(controller, context, poolId2);
             ScenarioTestHelpers.DeletePool(controller, context, poolId3);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

        /// <summary>
        /// Get Batch Context with keys
        /// </summary>
        public static BatchAccountContext GetBatchAccountContextWithKeys(BatchController controller, string accountName)
        {
            BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient);
            BatchAccountContext context = client.ListKeys(null, accountName);

            ScenarioTestContext testContext = new ScenarioTestContext(context);

            return testContext;
        }

 public void TestGetAndListComputeNodesWithSelect()
 {
     BatchController controller = BatchController.NewInstance;
     BatchAccountContext context = null;
     string computeNodeId = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-GetAndListComputeNodesWithSelect '{0}' '{1}'", poolId, computeNodeId) }; },
         () =>
         {
             context = new ScenarioTestContext();
             computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId);
         },
         null,
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

 public void TestListComputeNodesByFilter()
 {
     BatchController controller = BatchController.NewInstance;
     BatchAccountContext context = null;
     string state = "idle";
     int matches = 0;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-ListComputeNodesByFilter '{0}' '{1}' '{2}'", poolId, state, matches) }; },
         () =>
         {
             context = new ScenarioTestContext();
             matches = ScenarioTestHelpers.GetPoolCurrentDedicated(controller, context, poolId);
         },
         null,
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

        public void TestCreateComputeNodeUserPipeline()
        {
            BatchController controller = BatchController.NewInstance;
            BatchAccountContext context = null;
            string computeNodeId = null;
            string userName = "createuser2";
            controller.RunPsTestWorkflow(
                () => { return new string[] { string.Format("Test-CreateComputeNodeUser '{0}' '{1}' '{2}' 1", poolId, computeNodeId, userName) }; },
                () =>
                {
                    context = new ScenarioTestContext();
                    computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId);
                },
                null,
                TestUtilities.GetCallingClass(),
                TestUtilities.GetCurrentMethodName());

        }

 public void TestGetPoolById()
 {
     BatchController controller = BatchController.NewInstance;
     string poolId = "testGetPool";
     BatchAccountContext context = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-GetPoolById '{0}'", poolId) }; },
         () =>
         {
             context = new ScenarioTestContext();
             ScenarioTestHelpers.CreateTestPool(controller, context, poolId, 0);
         },
         () =>
         {
             ScenarioTestHelpers.DeletePool(controller, context, poolId);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

 public void TestGetCertificateByThumbprint()
 {
     BatchController controller = BatchController.NewInstance;
     BatchAccountContext context = null;
     string thumbprint = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-GetCertificateByThumbprint '{0}' '{1}'", BatchTestHelpers.TestCertificateAlgorithm, thumbprint) }; },
         () =>
         {
             context = new ScenarioTestContext();
             thumbprint = ScenarioTestHelpers.AddTestCertificate(controller, context, BatchTestHelpers.TestCertificateFileName1);
         },
         () =>
         {
             ScenarioTestHelpers.DeleteTestCertificate(controller, context, BatchTestHelpers.TestCertificateAlgorithm, thumbprint);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

 public void TestCreateTaskCollection()
 {
     BatchController controller = BatchController.NewInstance;
     string jobId = "createTaskCollectionJob";
     BatchAccountContext context = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-CreateTaskCollection '{0}'", jobId) }; },
         () =>
         {
             context = new ScenarioTestContext();
             ScenarioTestHelpers.CreateTestJob(controller, context, jobId);
         },
         () =>
         {
             ScenarioTestHelpers.DeleteJob(controller, context, jobId);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

 public void TestGetNodeFileByTaskByName()
 {
     BatchController controller = BatchController.NewInstance;
     string jobId = "testGetNodeFileByTaskJob";
     string taskId = "testTask";
     string nodeFileName = "stdout.txt";
     BatchAccountContext context = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-GetNodeFileByTaskByName '{0}' '{1}' '{2}'", jobId, taskId, nodeFileName) }; },
         () =>
         {
             context = new ScenarioTestContext();
             ScenarioTestHelpers.CreateTestJob(controller, context, jobId);
             ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId);
             ScenarioTestHelpers.WaitForTaskCompletion(controller, context, jobId, taskId);
         },
         () =>
         {
             ScenarioTestHelpers.DeleteJob(controller, context, jobId);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

 public void TestListNodeFilesByTaskByFilter()
 {
     BatchController controller = BatchController.NewInstance;
     string jobId = "listNodeFileByTaskFilterJob";
     string taskId = "testTask";
     string nodeFilePrefix = "std";
     int matches = 2;
     BatchAccountContext context = null;
     controller.RunPsTestWorkflow(
         () => { return new string[] { string.Format("Test-ListNodeFilesByTaskByFilter '{0}' '{1}' '{2}' '{3}'", jobId, taskId, nodeFilePrefix, matches) }; },
         () =>
         {
             context = new ScenarioTestContext();
             ScenarioTestHelpers.CreateTestJob(controller, context, jobId);
             ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId);
             ScenarioTestHelpers.WaitForTaskCompletion(controller, context, jobId, taskId);
         },
         () =>
         {
             ScenarioTestHelpers.DeleteJob(controller, context, jobId);
         },
         TestUtilities.GetCallingClass(),
         TestUtilities.GetCurrentMethodName());
 }

        private void TestGetComputeNodeRemoteLoginSettings(bool usePipeline, string testMethodName)
        {
            BatchController controller = BatchController.NewInstance;
            BatchAccountContext context = null;
            string computeNodeId = null;

            controller.RunPsTestWorkflow(
                () => { return new string[] { string.Format("Test-GetRemoteLoginSettings '{0}' '{1}' '{2}'", iaasPoolId, computeNodeId, usePipeline ? 1 : 0) }; },
                () =>
                {
                    context = new ScenarioTestContext();
                    computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, iaasPoolId);
                },
                null,
                TestUtilities.GetCallingClass(),
                testMethodName);
        }