public async Task Acquire_lock_multiple_times_work()
        {
            const string lockName = "my-lock";

            var locker = new SqlServerDistributedAppLockProvider(_connectionFactory,
                                                                 new SqlServerDistributedAppLockConfig
            {
                DisposeDbConnection = false
            });

            using (await locker.AcquireAsync(lockName))
            {
                // mutual exclusion scope here
            }

            using (await locker.AcquireAsync(lockName))
            {
                // mutual exclusion scope here
            }

            using (await locker.AcquireAsync(lockName))
            {
                // mutual exclusion scope here
            }
        }
        public async Task Acquire_with_auto_expiry_throws()
        {
            var ex = await Assert.ThrowsAsync <DistributedAppLockException>(async() =>
            {
                var locker = new SqlServerDistributedAppLockProvider(_connectionFactory);
                await locker.AcquireAsync("theLock", TimeSpan.Zero, TimeSpan.MaxValue);
            });

            Assert.IsAssignableFrom <NotSupportedException>(ex.InnerException);
        }
        public async Task Default_behavior_disposes_connection()
        {
            var hasBeenDisposed = false;

            _connection.Disposed += (sender, args) => { hasBeenDisposed = true; };

            var provider = new SqlServerDistributedAppLockProvider(_connectionFactory);
            var handle   = await provider.AcquireAsync("some-lock");

            handle.Dispose();

            await Task.Delay(50);

            Assert.True(hasBeenDisposed);
            Assert.Equal(ConnectionState.Closed, _connection.State);
        }
        public async Task Configured_behavior_leaves_connection_intact()
        {
            var hasBeenDisposed = false;

            _connection.Disposed += (sender, args) => { hasBeenDisposed = true; };

            var provider = new SqlServerDistributedAppLockProvider(_connectionFactory,
                                                                   new SqlServerDistributedAppLockConfig
            {
                DisposeDbConnection = false
            });

            var handle = await provider.AcquireAsync("some-lock");

            handle.Dispose();

            await Task.Delay(50);

            Assert.False(hasBeenDisposed);
            Assert.Equal(ConnectionState.Open, _connection.State);
        }
        public async Task Throws_if_given_connection_is_not_open()
        {
            var locker = new SqlServerDistributedAppLockProvider(() => new SqlConnection(_connectionString));
            var ex     = await Assert.ThrowsAsync <DistributedAppLockException>(async() => { await locker.AcquireAsync("TheLock"); });

            var arEx = Assert.IsAssignableFrom <ArgumentException>(ex.InnerException);

            Assert.Equal("dbConnection", arEx.ParamName);
        }