Exemplo n.º 1
0
        public async Task FreeLockAndPopScriptTests(string priorValue, string waiting)
        {
            var connection = ConfigurationHelper.GetNewConnection();
            var library    = new ScriptLibrary(connection);
            var db         = connection.GetDatabase();

            //SETUP
            var root       = Guid.NewGuid().ToString().Substring(0, 8);
            var parameters = new LockLuaParameters("id", new Key(root, "name", TimeSpan.FromMilliseconds(500)));

            try
            {
                await ResetKeys(db, parameters);

                if (!string.IsNullOrEmpty(priorValue))
                {
                    await db.StringSetAsync(parameters.LockKey, priorValue, TimeSpan.FromMilliseconds(parameters.Timeout));
                }

                if (!string.IsNullOrEmpty(waiting))
                {
                    await db.HashSetAsync(parameters.LockWaitingSetKey, waiting, 0);

                    await db.ListRightPushAsync(parameters.LockWaitingListKey, waiting);
                }

                var message = "";
                await connection.GetSubscriber().SubscribeAsync(parameters.LockNotifKey, (a, b) => message = b);

                //ACT
                await library.FreeLockAndPop(parameters);

                var locked = await db.StringGetAsync(parameters.LockKey);

                Assert.NotEqual(parameters.Identifier, (string)locked);

                if (priorValue == parameters.Identifier)
                {
                    if (waiting != "")
                    {
                        Assert.Equal(waiting, locked);
                        Assert.NotNull(await db.KeyTimeToLiveAsync(parameters.LockKey));

                        //doesn't work somehow
                        //Assert.NotNull(await db.KeyTimeToLiveAsync(parameters.LockWaitingListKey));
                        //Assert.NotNull(await db.KeyTimeToLiveAsync(parameters.LockWaitingSetKey));

                        await Task.Delay(50);

                        Assert.Equal(message, waiting);

                        await Task.Delay(450);

                        Assert.False(await db.KeyExistsAsync(parameters.LockKey));
                        Assert.False(await db.KeyExistsAsync(parameters.LockWaitingListKey));
                        Assert.False(await db.KeyExistsAsync(parameters.LockWaitingSetKey));
                    }
                    else
                    {
                        Assert.Equal(RedisValue.Null, locked);
                        Assert.False(await db.KeyExistsAsync(parameters.LockKey));
                        Assert.False(await db.KeyExistsAsync(parameters.LockWaitingListKey));
                        Assert.False(await db.KeyExistsAsync(parameters.LockWaitingSetKey));
                    }
                }
            }
            finally
            {
                await ResetKeys(db, parameters);
            }
        }
Exemplo n.º 2
0
        public async Task GetLockOrSubscribeTests(string priorValue, string waiting, bool expectedResult)
        {
            var connection = ConfigurationHelper.GetNewConnection();
            var library    = new ScriptLibrary(connection);
            var db         = connection.GetDatabase();

            //SETUP
            var root       = Guid.NewGuid().ToString().Substring(0, 8);
            var parameters = new LockLuaParameters("id", new Key(root, "name", TimeSpan.FromMilliseconds(500)));

            try
            {
                await ResetKeys(db, parameters);

                if (!string.IsNullOrEmpty(priorValue))
                {
                    await db.StringSetAsync(parameters.LockKey, priorValue, TimeSpan.FromMilliseconds(parameters.Timeout));
                }

                if (!string.IsNullOrEmpty(waiting))
                {
                    await db.HashSetAsync(parameters.LockWaitingSetKey, waiting, 0);

                    await db.KeyExpireAsync(parameters.LockWaitingSetKey, TimeSpan.FromMilliseconds(parameters.Timeout));

                    await db.ListRightPushAsync(parameters.LockWaitingListKey, waiting);

                    await db.KeyExpireAsync(parameters.LockWaitingListKey, TimeSpan.FromMilliseconds(parameters.Timeout));
                }

                //ACT
                var result = await library.GetLockOrAddToQueue(parameters);

                //ASSERT
                Assert.Equal(expectedResult, result);
                if (expectedResult)
                {
                    Assert.Equal(parameters.Identifier, await db.StringGetAsync(parameters.LockKey));
                    Assert.Equal(!string.IsNullOrEmpty(waiting), await db.KeyExistsAsync(parameters.LockWaitingListKey));
                    Assert.Equal(!string.IsNullOrEmpty(waiting), await db.KeyExistsAsync(parameters.LockWaitingSetKey));
                }
                else
                {
                    var lockKey = (string)await db.StringGetAsync(parameters.LockKey);

                    Assert.NotEmpty(lockKey);
                    Assert.NotEqual(parameters.Identifier, lockKey);
                    Assert.Contains(parameters.Identifier, await db.ListRangeAsync(parameters.LockWaitingListKey));
                    Assert.Contains(parameters.Identifier, (await db.HashGetAllAsync(parameters.LockWaitingSetKey)).Select(e => e.Name));
                }

                //expiration delay
                await Task.Delay((int)parameters.Timeout + 50);

                Assert.False(await db.KeyExistsAsync(parameters.LockKey));
                Assert.False(await db.KeyExistsAsync(parameters.LockWaitingListKey));
                Assert.False(await db.KeyExistsAsync(parameters.LockWaitingSetKey));
            }
            finally
            {
                await ResetKeys(db, parameters);
            }
        }