public virtual RedisClient CreateRedisClient(RedisEndpoint config, bool master)
        {
            var client = ClientFactory(config);

            if (master && RedisConfig.VerifyMasterConnections)
            {
                var       firstAttempt  = DateTime.UtcNow;
                Exception firstEx       = null;
                var       retryTimeSpan = TimeSpan.FromMilliseconds(config.RetryTimeout);
                var       i             = 0;
                while (DateTime.UtcNow - firstAttempt < retryTimeSpan)
                {
                    try
                    {
                        client = GetValidMaster(client, config);
                        return(client);
                    }
                    catch (Exception ex)
                    {
                        if (!RedisConfig.RetryReconnectOnFailedMasters)
                        {
                            throw;
                        }

                        firstEx ??= ex;
                        ExecUtils.SleepBackOffMultiplier(++i);
                    }
                }
                throw new TimeoutException($"Could not resolve master instance within {config.RetryTimeout}ms RetryTimeout", firstEx);
            }

            return(client);
        }
    public void Can_use_RefreshTokenCookie_to_authenticate_and_get_new_AccessToken()
    {
        string initialAccessToken = null;
        var    client             = new JsonServiceClient(Config.ListeningOn)
        {
            ResponseFilter = res => {
                if (initialAccessToken == null)
                {
                    var accessToken = res.Cookies[Keywords.TokenCookie];
                    Assert.That(accessToken.Value, Is.Not.Null);
                    initialAccessToken = accessToken.Value;
                    var refreshToken = res.Cookies[Keywords.RefreshTokenCookie];
                    Assert.That(refreshToken.Value, Is.Not.Null);
                }
            }
        };
        var authResponse = client.Post(new Authenticate {
            provider = "credentials",
            UserName = Username,
            Password = Password
        });

        var request = new Secured {
            Name = "test"
        };
        var response = client.Send(request);

        Assert.That(response.Result, Is.EqualTo(request.Name));

        var reqLogger        = HostContext.TryResolve <IRequestLogger>();
        var lastEntrySession = reqLogger.GetLatestLogs(1)[0]?.Session as AuthUserSession;

        Assert.That(lastEntrySession, Is.Not.Null);
        Assert.That(lastEntrySession.AuthProvider, Is.EqualTo("jwt"));
        Assert.That(lastEntrySession.UserName, Is.EqualTo(Username));

        string lastAccessToken = null;

        client.ResponseFilter = res => {
            var accessToken = res.Cookies[Keywords.TokenCookie];
            lastAccessToken = accessToken.Value;
        };
        var i = 0;

        do
        {
            var accessTokenResponse = client.Post(new GetAccessToken());
            ExecUtils.SleepBackOffMultiplier(++i); //need to wait for iat to tick +1s so JWT's are different
        }while (lastAccessToken == initialAccessToken);
    }