public async Task ConnectWorker_FollowsFailureOptionsIfTheDeserializerThrows(WorkerFailureBehavior behavior)
        {
            await ConnectAsync();

            await prod.UseAsync("watched");

            await DrainUsedTube();

            // Ensure all messages will fail horribly during deserialization
            var configuration = ConnectionConfiguration.Parse(connectionString);

            configuration.JobSerializer = new ThrowingSerializer();

            bool gotInsideWorkerFunc = false;

            var options = new WorkerOptions
            {
                Tubes               = { "watched" },
                FailureBehavior     = behavior,
                FailureReleaseDelay = TenSeconds,
            };
            var worker = BeanstalkConnection.ConnectWorkerAsync <Jobject>(configuration, options, async(c, _) =>
            {
                gotInsideWorkerFunc = true;
                await c.DeleteAsync();
            });

            int jobId;

            using (await worker)
            {
                jobId = await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds);

                await Task.Delay(200);

                Assert.False(gotInsideWorkerFunc);

                var stats = await prod.JobStatisticsAsync(jobId);

                switch (behavior)
                {
                case WorkerFailureBehavior.Delete: Assert.Null(stats); return;

                case WorkerFailureBehavior.Bury: Assert.Equal(JobState.Buried, stats.State); return;

                case WorkerFailureBehavior.Release: Assert.Equal(JobState.Delayed, stats.State); return;

                case WorkerFailureBehavior.NoAction: Assert.Equal(JobState.Reserved, stats.State); return;

                default: throw new Exception("Untested behavior: " + behavior);
                }
            }
        }
        public async Task ConnectWorker_ThrownExceptionFollowsSpecifiedBehavior(WorkerFailureBehavior behavior)
        {
            await ConnectAsync();

            var tube = "test-failure-behaviors";
            await prod.UseAsync(tube);

            await DrainUsedTube();

            var options = new WorkerOptions
            {
                Tubes               = { tube },
                FailureBehavior     = behavior,
                FailurePriority     = 1,
                FailureReleaseDelay = TimeSpan.FromSeconds(10),
            };
            var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, (c, job) =>
            {
                throw new Exception();
            });

            JobStatistics stats;

            using (await worker)
            {
                var id = await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds);

                await Task.Delay(100);

                stats = await prod.JobStatisticsAsync(id);
            }

            switch (behavior)
            {
            case WorkerFailureBehavior.Delete: Assert.Null(stats); return;

            case WorkerFailureBehavior.Bury: Assert.Equal(JobState.Buried, stats.State); return;

            case WorkerFailureBehavior.Release: Assert.Equal(JobState.Delayed, stats.State); return;

            case WorkerFailureBehavior.NoAction: Assert.Equal(JobState.Reserved, stats.State); return;

            default: throw new Exception("Untested behavior");
            }
        }
        public async Task ConnectWorker_ThrownExceptionFollowsSpecifiedBehavior(WorkerFailureBehavior behavior)
        {
            await ConnectAsync();
            var tube = "test-failure-behaviors";
            await prod.UseAsync(tube);
            await DrainUsedTube();

            var options = new WorkerOptions
            {
                Tubes = { tube },
                FailureBehavior = behavior,
                FailurePriority = 1,
                FailureReleaseDelay = TimeSpan.FromSeconds(10),
            };
            var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, (c, job) =>
            {
                throw new Exception();
            });

            JobStatistics stats;
            using (await worker)
            {
                var id = await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds);
                await Task.Delay(100);
                stats = await prod.JobStatisticsAsync(id);
            }

            switch (behavior)
            {
                case WorkerFailureBehavior.Delete: Assert.Null(stats); return;
                case WorkerFailureBehavior.Bury: Assert.Equal(JobState.Buried, stats.State); return;
                case WorkerFailureBehavior.Release: Assert.Equal(JobState.Delayed, stats.State); return;
                case WorkerFailureBehavior.NoAction: Assert.Equal(JobState.Reserved, stats.State); return;
                default: throw new Exception("Untested behavior");
            }
        }