public async Task DurableGetInstancesTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string taskHubName = "getInstancesTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable get-instances --task-hub-name {taskHubName}"
                },
                OutputContains = new string[]
                {
                    "Continuation token for next set of results:"
                }
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : false);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurableTerminateTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string instanceId  = $"{Guid.NewGuid():N}";
            string taskHubName = "terminateTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable start-new --function-name Counter --id {instanceId} --task-hub-name {taskHubName}",
                    $"durable terminate --id {instanceId} --task-hub-name {taskHubName}"
                },
                OutputContains = new string[]
                {
                    $"Successfully terminated '{instanceId}'"
                },
                CommandTimeout = TimeSpan.FromSeconds(45)
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : true);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurableGetHistoryTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string instanceId  = $"{Guid.NewGuid():N}";
            string taskHubName = "getHistoryTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable start-new --function-name Counter --id {instanceId} --task-hub-name {taskHubName}",
                    $"durable raise-event --id {instanceId} --event-name operation --event-data add --task-hub-name {taskHubName}",
                    $"durable get-history --id {instanceId} --task-hub-name {taskHubName}"
                },
                OutputContains = new string[]
                {
                    "Started 'Counter'",
                    "OrchestratorStarted",
                    "ExecutionStarted",
                    "OrchestratorCompleted"
                },
                CommandTimeout = TimeSpan.FromSeconds(45)
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : true);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurableDeleteTaskHubTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string taskHubName = "deleteTaskHubTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable delete-task-hub --task-hub-name {taskHubName}",
                },
                OutputContains = new string[]
                {
                    $"Task hub '{taskHubName}' successfully deleted."
                }
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : false);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurableStartNewTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string taskHubName = "startNewTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable start-new --function-name Counter --input 3 --task-hub-name {taskHubName}"
                },
                OutputContains = new string[]
                {
                    "Started 'Counter'"
                }
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : false);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurableRaiseEventTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string instanceId  = $"{Guid.NewGuid():N}";
            string taskHubName = "raiseEventTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable start-new --function-name Counter --input 3 --id {instanceId} --task-hub-name {taskHubName}",
                    $"durable raise-event --id {instanceId} --event-name operation --event-data add --task-hub-name {taskHubName}"
                },
                OutputContains = new string[]
                {
                    $"Raised event 'operation' to instance '{instanceId}'"
                }
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : false);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurablePurgeHistoryTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string taskHubName = "purgeHistoryTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable purge-history --task-hub-name {taskHubName}"
                },
                OutputContains = new string[]
                {
                    "Purged orchestration history for all instances created between '1/1/0001 12:00:00 AM' and '12/30/9999 11:59:59 PM'"
                },
                CommandTimeout = TimeSpan.FromSeconds(45)
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : true);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurableGetRuntimeStatusTest()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string instanceId  = $"{Guid.NewGuid():N}";
            string taskHubName = "getRuntimeStatusTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable get-runtime-status --id {instanceId} --task-hub-name {taskHubName}"
                },
                OutputContains = new string[]
                {
                    $"Could not find an orchestration instance with id '{instanceId}"
                }
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : false);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);
        }
        public async Task DurableRaiseEventTest_FileInput()
        {
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string taskHubName = "raiseEventFileInputTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            string filename   = Path.Combine(WorkingDirPath, "raiseEvent.json");
            var    testObject = new
            {
                Name  = "RaiseEvent",
                Hello = "World"
            };

            File.WriteAllText(filename, JsonConvert.SerializeObject(testObject));

            string instanceId = $"{Guid.NewGuid():N}";

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable start-new --function-name JsonInput --id {instanceId} --task-hub-name {taskHubName}",
                    $"durable raise-event --id {instanceId} --event-name operation --event-data @raiseEvent.json --task-hub-name {taskHubName}",
                    $"durable get-runtime-status --id {instanceId}"
                },
                OutputContains = new string[]
                {
                    $"Raised event 'operation' to instance '{instanceId}'",
                    "\"OrchestrationStatus\": 0",
                }
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : true);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);

            File.Delete(filename);
        }
        public async Task DurableStartNewTest_FileInput()
        {
            Skip.If(true, reason: "This test fails intermittently, needs to be fixed");
            Skip.If(string.IsNullOrEmpty(StorageConnectionString),
                    reason: _storageReason);

            string taskHubName = "startNewFileInputTest";

            DurableHelper.SetTaskHubName(WorkingDirPath, taskHubName);
            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, StorageConnectionString);

            string filename   = Path.Combine(WorkingDirPath, "startnew.json");
            var    testObject = new
            {
                Name  = "StartNew",
                Hello = "World"
            };

            File.WriteAllText(filename, JsonConvert.SerializeObject(testObject));

            string instanceId = $"{Guid.NewGuid():N}";

            await CliTester.Run(new RunConfiguration
            {
                Commands = new[]
                {
                    $"durable start-new --function-name JsonInput --input @startnew.json --task-hub-name {taskHubName} --id {instanceId}",
                    $"durable get-runtime-status --id {instanceId}"
                },
                OutputContains = new string[]
                {
                    "Started 'JsonInput'",
                    "\"OrchestrationStatus\": 0",
                }
            },
                                _output,
                                workingDir : WorkingDirPath,
                                startHost : true);

            Environment.SetEnvironmentVariable(DurableManager.DefaultConnectionStringKey, null);

            File.Delete(filename);
        }