mperham--sidekiq/test/test_redis_connection.rb

# frozen_string_literal: true

require_relative "helper"
require "sidekiq/cli"

describe Sidekiq::RedisConnection do
  describe "create" do
    before do
      Sidekiq.options = Sidekiq::DEFAULTS.dup
      @old = ENV["REDIS_URL"]
      ENV["REDIS_URL"] = "redis://localhost/15"
    end

    after do
      ENV["REDIS_URL"] = @old
    end

    # To support both redis-rb 3.3.x #client and 4.0.x #_client
    def client_for(redis)
      if redis.respond_to?(:_client)
        redis._client
      else
        redis.client
      end
    end

    it "creates a pooled redis connection" do
      pool = Sidekiq::RedisConnection.create
      assert_equal Redis, pool.checkout.class
    end

    # Readers for these ivars should be available in the next release of
    # `connection_pool`, until then we need to reach into the internal state to
    # verify the setting.
    describe "size" do
      def client_connection(*args)
        Sidekiq.stub(:server?, nil) do
          Sidekiq::RedisConnection.create(*args)
        end
      end

      def server_connection(*args)
        Sidekiq.stub(:server?, "constant") do
          Sidekiq::RedisConnection.create(*args)
        end
      end

      it "uses the specified custom pool size" do
        pool = client_connection(size: 42)
        assert_equal 42, pool.instance_eval { @size }
        assert_equal 42, pool.instance_eval { @available.length }

        pool = server_connection(size: 42)
        assert_equal 42, pool.instance_eval { @size }
        assert_equal 42, pool.instance_eval { @available.length }
      end

      it "defaults server pool sizes based on concurrency with padding" do
        _expected_padding = 5
        prev_concurrency = Sidekiq.options[:concurrency]
        Sidekiq.options[:concurrency] = 6
        pool = server_connection

        assert_equal 11, pool.instance_eval { @size }
        assert_equal 11, pool.instance_eval { @available.length }
      ensure
        Sidekiq.options[:concurrency] = prev_concurrency
      end

      it "defaults client pool sizes to 5" do
        pool = client_connection

        assert_equal 5, pool.instance_eval { @size }
        assert_equal 5, pool.instance_eval { @available.length }
      end

      it "changes client pool sizes with ENV" do
        ENV["RAILS_MAX_THREADS"] = "9"
        pool = client_connection

        assert_equal 9, pool.instance_eval { @size }
        assert_equal 9, pool.instance_eval { @available.length }
      ensure
        ENV.delete("RAILS_MAX_THREADS")
      end
    end

    it "disables client setname with nil id" do
      pool = Sidekiq::RedisConnection.create(id: nil)
      assert_equal Redis, pool.checkout.class
      assert_equal "redis://localhost:6379/15", pool.checkout.connection.fetch(:id)
    end

    describe "network_timeout" do
      it "sets a custom network_timeout if specified" do
        pool = Sidekiq::RedisConnection.create(network_timeout: 8)
        redis = pool.checkout

        assert_equal 8, client_for(redis).timeout
      end

      it "uses the default network_timeout if none specified" do
        pool = Sidekiq::RedisConnection.create
        redis = pool.checkout

        assert_equal 5, client_for(redis).timeout
      end
    end

    describe "namespace" do
      it "uses a given :namespace set by a symbol key" do
        pool = Sidekiq::RedisConnection.create(namespace: "xxx")
        assert_equal "xxx", pool.checkout.namespace
      end

      it "uses a given :namespace set by a string key" do
        pool = Sidekiq::RedisConnection.create("namespace" => "xxx")
        assert_equal "xxx", pool.checkout.namespace
      end

      it "uses given :namespace over :namespace from Sidekiq.options" do
        Sidekiq.options[:namespace] = "xxx"
        pool = Sidekiq::RedisConnection.create(namespace: "yyy")
        assert_equal "yyy", pool.checkout.namespace
      end
    end

    describe "socket path" do
      it "uses a given :path" do
        pool = Sidekiq::RedisConnection.create(path: "/var/run/redis.sock")
        assert_equal "unix", client_for(pool.checkout).scheme
        assert_equal "/var/run/redis.sock", pool.checkout.connection.fetch(:location)
        assert_equal 15, pool.checkout.connection.fetch(:db)
      end

      it "uses a given :path and :db" do
        pool = Sidekiq::RedisConnection.create(path: "/var/run/redis.sock", db: 8)
        assert_equal "unix", client_for(pool.checkout).scheme
        assert_equal "/var/run/redis.sock", pool.checkout.connection.fetch(:location)
        assert_equal 8, pool.checkout.connection.fetch(:db)
      end
    end

    describe "pool_timeout" do
      it "uses a given :timeout over the default of 1" do
        pool = Sidekiq::RedisConnection.create(pool_timeout: 5)

        assert_equal 5, pool.instance_eval { @timeout }
      end

      it "uses the default timeout of 1 if no override" do
        pool = Sidekiq::RedisConnection.create

        assert_equal 1, pool.instance_eval { @timeout }
      end
    end

    describe "driver" do
      it "uses redis' ruby driver" do
        pool = Sidekiq::RedisConnection.create
        redis = pool.checkout

        assert_equal Redis::Connection::Ruby, redis.instance_variable_get(:@client).driver
      end

      it "uses redis' default driver if there are many available" do
        redis_driver = Object.new
        Redis::Connection.drivers << redis_driver

        pool = Sidekiq::RedisConnection.create
        redis = pool.checkout

        assert_equal redis_driver, redis.instance_variable_get(:@client).driver
      ensure
        Redis::Connection.drivers.pop
      end

      it "uses a given :driver" do
        redis_driver = Object.new
        pool = Sidekiq::RedisConnection.create(driver: redis_driver)
        redis = pool.checkout

        assert_equal redis_driver, redis.instance_variable_get(:@client).driver
      end
    end

    describe "logging redis options" do
      it "redacts credentials" do
        options = {
          role: "master",
          master_name: "mymaster",
          sentinels: [
            {host: "host1", port: 26379, password: "secret"},
            {host: "host2", port: 26379, password: "secret"},
            {host: "host3", port: 26379, password: "secret"}
          ],
          password: "secret"
        }

        output = capture_logging do
          Sidekiq::RedisConnection.create(options)
        end

        refute_includes(options.inspect, "REDACTED")
        assert_includes(output, ':host=>"host1", :port=>26379, :password=>"REDACTED"')
        assert_includes(output, ':host=>"host2", :port=>26379, :password=>"REDACTED"')
        assert_includes(output, ':host=>"host3", :port=>26379, :password=>"REDACTED"')
        assert_includes(output, ':password=>"REDACTED"')
      end

      it "prunes SSL parameters from the logging" do
        options = {
          ssl_params: {
            cert_store: OpenSSL::X509::Store.new
          }
        }

        output = capture_logging do
          Sidekiq::RedisConnection.create(options)
        end

        assert_includes(options.inspect, "ssl_params")
        refute_includes(output, "ssl_params")
      end
    end
  end

  describe ".determine_redis_provider" do
    before do
      @old_env = ENV.to_hash
    end

    after do
      ENV.update(@old_env)
    end

    def with_env_var(var, uri, skip_provider = false)
      vars = ["REDISTOGO_URL", "REDIS_PROVIDER", "REDIS_URL"] - [var]
      vars.each do |v|
        next if skip_provider
        ENV[v] = nil
      end
      ENV[var] = uri
      assert_equal uri, Sidekiq::RedisConnection.__send__(:determine_redis_provider)
      ENV[var] = nil
    end

    describe "with REDISTOGO_URL and a parallel REDIS_PROVIDER set" do
      it "sets connection URI to the provider" do
        uri = "redis://sidekiq-redis-provider:6379/0"
        provider = "SIDEKIQ_REDIS_PROVIDER"

        ENV["REDIS_PROVIDER"] = provider
        ENV[provider] = uri
        ENV["REDISTOGO_URL"] = "redis://redis-to-go:6379/0"
        with_env_var provider, uri, true

        ENV[provider] = nil
      end
    end

    describe "with REDIS_PROVIDER set" do
      it "rejects URLs in REDIS_PROVIDER" do
        uri = "redis://sidekiq-redis-provider:6379/0"

        ENV["REDIS_PROVIDER"] = uri

        assert_raises RuntimeError do
          Sidekiq::RedisConnection.__send__(:determine_redis_provider)
        end

        ENV["REDIS_PROVIDER"] = nil
      end

      it "sets connection URI to the provider" do
        uri = "redis://sidekiq-redis-provider:6379/0"
        provider = "SIDEKIQ_REDIS_PROVIDER"

        ENV["REDIS_PROVIDER"] = provider
        ENV[provider] = uri

        with_env_var provider, uri, true

        ENV[provider] = nil
      end
    end

    describe "with REDIS_URL set" do
      it "sets connection URI to custom uri" do
        with_env_var "REDIS_URL", "redis://redis-uri:6379/0"
      end
    end
  end
end