Skip to content

A platform for community discussion. Free, open, simple.

4.9 KB
Raw Blame
# frozen_string_literal: true

RSpec.describe DiscourseDataExplorer::QueryResultCache do
  fab!(:user)
  fab!(:admin)
  fab!(:query) { Fabricate(:query, sql: "SELECT 1") }

  let(:params_hash) { { "limit" => "10", "name" => "test" } }
  let(:result_json) do
    {
      "success" => true,
      "columns" => %w[id],
      "rows" => [[1], [2]],
      "result_count" => 2,
      "duration" => 1.5,
      "params" => params_hash,
      "relations" => {
      },
      "colrender" => {
      },
      "default_limit" => 1000,
    }
  end

  after { described_class.invalidate(query.id) }

  describe ".write and .read" do
    it "stores and retrieves results" do
      described_class.write(query.id, user, params_hash, result_json)
      cached = described_class.read(query.id, user, params_hash)

      expect(cached["success"]).to eq(true)
      expect(cached["rows"]).to eq([[1], [2]])
      expect(cached["cached_at"]).to be_present
    end

    it "returns nil on cache miss" do
      expect(described_class.read(query.id, user, params_hash)).to be_nil
    end

    it "returns nil when the cached result exceeds the maximum age" do
      now = Time.now
      freeze_time(now)
      described_class.write(query.id, user, params_hash, result_json)

      freeze_time(now + 1.hour + 1.second)
      expect(described_class.read(query.id, user, params_hash, max_age: 1.hour)).to be_nil
    end

    it "skips write when result exceeds max size" do
      large_result = result_json.merge("rows" => [["x" * (described_class::MAX_CACHE_SIZE + 1)]])

      expect(described_class.write(query.id, user, params_hash, large_result)).to eq(false)
      expect(described_class.read(query.id, user, params_hash)).to be_nil
    end

    it "sets a TTL on the cache key" do
      described_class.write(query.id, user, params_hash, result_json)
      key = described_class.cache_key(query.id, user, params_hash)
      ttl = Discourse.redis.ttl(key)

      expect(ttl).to be > 0
      expect(ttl).to be <= described_class::CACHE_TTL
    end

    it "evicts the oldest entry once the per-query limit is reached" do
      stub_const(described_class, :MAX_CACHE_ENTRIES, 2) do
        described_class.write(query.id, user, { "value" => "0" }, result_json)
        described_class.write(query.id, user, { "value" => "1" }, result_json)

        expect(described_class.write(query.id, admin, params_hash, result_json)).to eq(true)
        expect(described_class.read(query.id, user, { "value" => "0" })).to be_nil
        expect(described_class.read(query.id, admin, params_hash)).to be_present
        expect(Discourse.redis.zcard(described_class.cache_index_key(query.id))).to eq(2)
      end
    end

    it "caches new entries after old index members expire" do
      stub_const(described_class, :MAX_CACHE_ENTRIES, 2) do
        stale_score = Time.now.to_f - described_class::CACHE_TTL - 1
        Discourse.redis.zadd(
          described_class.cache_index_key(query.id),
          [[stale_score, "stale:0"], [stale_score, "stale:1"]],
        )

        expect(described_class.write(query.id, user, params_hash, result_json)).to eq(true)
        expect(described_class.read(query.id, user, params_hash)).to be_present
      end
    end
  end

  describe ".read" do
    subject(:cached_result) { described_class.read(query.id, user, params_hash) }

    context "when the cached result contains malformed JSON" do
      before do
        Discourse.redis.set(described_class.cache_key(query.id, user, params_hash), "not-json")
      end

      it "returns a cache miss" do
        expect(cached_result).to be_nil
      end
    end
  end

  describe ".cache_key" do
    it "produces the same key regardless of param order" do
      key_a = described_class.cache_key(query.id, user, { "b" => "2", "a" => "1" })
      key_b = described_class.cache_key(query.id, user, { "a" => "1", "b" => "2" })

      expect(key_a).to eq(key_b)
    end

    it "produces different keys for different params" do
      key_a = described_class.cache_key(query.id, user, { "a" => "1" })
      key_b = described_class.cache_key(query.id, user, { "a" => "2" })

      expect(key_a).not_to eq(key_b)
    end
  end

  describe ".invalidate" do
    it "removes all cached results for a query" do
      described_class.write(query.id, user, params_hash, result_json)
      described_class.write(query.id, admin, params_hash, result_json)

      described_class.invalidate(query.id)

      expect(described_class.read(query.id, user, params_hash)).to be_nil
      expect(described_class.read(query.id, admin, params_hash)).to be_nil
    end

    it "does not affect other queries" do
      other_query = Fabricate(:query, sql: "SELECT 2")

      described_class.write(query.id, user, params_hash, result_json)
      described_class.write(other_query.id, user, params_hash, result_json)

      described_class.invalidate(query.id)

      expect(described_class.read(query.id, user, params_hash)).to be_nil
      expect(described_class.read(other_query.id, user, params_hash)).to be_present
    end
  end
end