mudis-ql 0.1.0

data/spec/mudis-ql/metrics_scope_spec.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+RSpec.describe MudisQL::MetricsScope do
+  before do
+    Mudis.serializer = JSON
+    Mudis.reset!
+    Mudis.reset_metrics!
+
+    # Create some cache activity to generate metrics
+    10.times do |i|
+      Mudis.write("key#{i}", { value: i }, namespace: "test")
+    end
+
+    # Create some reads for hits
+    5.times { |i| Mudis.read("key#{i}", namespace: "test") }
+
+    # Try to read non-existent keys for misses
+    3.times { |i| Mudis.read("missing#{i}", namespace: "test") }
+  end
+
+  let(:metrics_scope) { described_class.new }
+
+  describe "#summary" do
+    it "returns top-level metrics without arrays" do
+      summary = metrics_scope.summary
+
+      expect(summary).to have_key(:hits)
+      expect(summary).to have_key(:misses)
+      expect(summary).to have_key(:evictions)
+      expect(summary).not_to have_key(:least_touched)
+      expect(summary).not_to have_key(:buckets)
+    end
+
+    it "shows correct hit and miss counts" do
+      summary = metrics_scope.summary
+
+      expect(summary[:hits]).to eq(5)
+      expect(summary[:misses]).to eq(3)
+    end
+  end
+
+  describe "#least_touched" do
+    it "returns a Scope object" do
+      result = metrics_scope.least_touched
+
+      expect(result).to be_a(MudisQL::Scope)
+    end
+
+    it "can be queried with where" do
+      result = metrics_scope.least_touched
+        .where(access_count: 0)
+        .all
+
+      expect(result).to be_an(Array)
+    end
+
+    it "can be ordered by access count" do
+      result = metrics_scope.least_touched
+        .order(:access_count)
+        .limit(5)
+        .all
+
+      expect(result.size).to be <= 5
+    end
+
+    it "can pluck just keys" do
+      keys = metrics_scope.least_touched
+        .where(access_count: 0)
+        .pluck(:key)
+
+      expect(keys).to be_an(Array)
+      expect(keys).to all(be_a(String))
+    end
+  end
+
+  describe "#buckets" do
+    it "returns a Scope object" do
+      result = metrics_scope.buckets
+
+      expect(result).to be_a(MudisQL::Scope)
+    end
+
+    it "can query buckets with conditions" do
+      result = metrics_scope.buckets
+        .where(keys: ->(k) { k && k > 0 })
+        .all
+
+      expect(result).to be_an(Array)
+      result.each do |bucket|
+        expect(bucket[:keys]).to be > 0
+      end
+    end
+
+    it "can order buckets by memory" do
+      result = metrics_scope.buckets
+        .order(:memory_bytes, :desc)
+        .all
+
+      if result.size > 1
+        expect(result.first[:memory_bytes]).to be >= result.last[:memory_bytes]
+      end
+    end
+
+    it "can find buckets by index" do
+      result = metrics_scope.buckets
+        .where(index: 0)
+        .first
+
+      expect(result).to be_a(Hash) if result
+    end
+  end
+
+  describe "#total_keys" do
+    it "returns the sum of keys across all buckets" do
+      total = metrics_scope.total_keys
+
+      expect(total).to eq(10)
+    end
+  end
+
+  describe "#total_memory" do
+    it "returns total memory usage" do
+      memory = metrics_scope.total_memory
+
+      expect(memory).to be_a(Integer)
+      expect(memory).to be > 0
+    end
+  end
+
+  describe "#hit_rate" do
+    it "calculates hit rate percentage" do
+      rate = metrics_scope.hit_rate
+
+      expect(rate).to be_a(Float)
+      expect(rate).to be_between(0, 100)
+      # 5 hits, 3 misses = 5/8 = 62.5%
+      expect(rate).to eq(62.5)
+    end
+
+    it "returns 0 when no operations" do
+      Mudis.reset_metrics!
+      rate = metrics_scope.refresh.hit_rate
+
+      expect(rate).to eq(0.0)
+    end
+  end
+
+  describe "#efficiency" do
+    it "returns efficiency metrics" do
+      eff = metrics_scope.efficiency
+
+      expect(eff).to have_key(:hit_rate)
+      expect(eff).to have_key(:miss_rate)
+      expect(eff).to have_key(:eviction_rate)
+      expect(eff).to have_key(:rejection_rate)
+    end
+
+    it "has hit_rate and miss_rate that sum to 100" do
+      eff = metrics_scope.efficiency
+
+      expect(eff[:hit_rate] + eff[:miss_rate]).to eq(100.0)
+    end
+  end
+
+  describe "#high_memory_buckets" do
+    it "finds buckets exceeding memory threshold" do
+      buckets = metrics_scope.high_memory_buckets(1000)
+
+      expect(buckets).to be_an(Array)
+      buckets.each do |bucket|
+        expect(bucket[:memory_bytes]).to be > 1000
+      end
+    end
+
+    it "returns empty array when threshold too high" do
+      buckets = metrics_scope.high_memory_buckets(999_999_999)
+
+      expect(buckets).to be_empty
+    end
+  end
+
+  describe "#high_key_buckets" do
+    it "finds buckets with many keys" do
+      buckets = metrics_scope.high_key_buckets(0)
+
+      expect(buckets).to be_an(Array)
+      buckets.each do |bucket|
+        expect(bucket[:keys]).to be > 0
+      end
+    end
+
+    it "filters by threshold" do
+      buckets = metrics_scope.high_key_buckets(5)
+
+      buckets.each do |bucket|
+        expect(bucket[:keys]).to be > 5
+      end
+    end
+  end
+
+  describe "#bucket_distribution" do
+    it "returns distribution statistics" do
+      dist = metrics_scope.bucket_distribution
+
+      expect(dist).to have_key(:total_buckets)
+      expect(dist).to have_key(:avg_keys_per_bucket)
+      expect(dist).to have_key(:max_keys_per_bucket)
+      expect(dist).to have_key(:min_keys_per_bucket)
+      expect(dist).to have_key(:avg_memory_per_bucket)
+    end
+
+    it "calculates correct totals" do
+      dist = metrics_scope.bucket_distribution
+
+      expect(dist[:total_buckets]).to be > 0
+      expect(dist[:max_keys_per_bucket]).to be >= dist[:min_keys_per_bucket]
+    end
+  end
+
+  describe "#never_accessed_keys" do
+    it "returns keys with zero access count" do
+      keys = metrics_scope.never_accessed_keys
+
+      expect(keys).to be_an(Array)
+      expect(keys.size).to be > 0
+    end
+
+    it "returns only string keys" do
+      keys = metrics_scope.never_accessed_keys
+
+      expect(keys).to all(be_a(String))
+    end
+  end
+
+  describe "#refresh" do
+    it "updates metrics data" do
+      old_hits = metrics_scope.summary[:hits]
+
+      # Generate more activity
+      Mudis.read("key0", namespace: "test")
+
+      new_hits = metrics_scope.refresh.summary[:hits]
+
+      expect(new_hits).to be > old_hits
+    end
+
+    it "returns self for chaining" do
+      result = metrics_scope.refresh
+
+      expect(result).to eq(metrics_scope)
+    end
+  end
+
+  describe "integration scenarios" do
+    it "identifies hotspots - most accessed keys" do
+      # Access some keys multiple times
+      10.times { Mudis.read("key0", namespace: "test") }
+      5.times { Mudis.read("key1", namespace: "test") }
+
+      most_accessed = MudisQL.metrics.refresh.least_touched
+        .order(:access_count, :desc)
+        .limit(5)
+        .all
+
+      expect(most_accessed).to be_an(Array)
+      if most_accessed.size > 1 && most_accessed.first[:access_count] && most_accessed.last[:access_count]
+        expect(most_accessed.first[:access_count]).to be >= most_accessed.last[:access_count]
+      end
+    end
+
+    it "finds unbalanced buckets" do
+      dist = MudisQL.metrics.bucket_distribution
+      avg_keys = dist[:avg_keys_per_bucket]
+
+      unbalanced = MudisQL.metrics.buckets
+        .where(keys: ->(k) { k && k > avg_keys * 1.5 })
+        .all
+
+      expect(unbalanced).to be_an(Array)
+    end
+
+    it "monitors cache health" do
+      health = {
+        hit_rate: MudisQL.metrics.hit_rate,
+        total_keys: MudisQL.metrics.total_keys,
+        memory: MudisQL.metrics.total_memory,
+        efficiency: MudisQL.metrics.efficiency
+      }
+
+      expect(health[:hit_rate]).to be_a(Float)
+      expect(health[:total_keys]).to be_a(Integer)
+      expect(health[:memory]).to be_a(Integer)
+      expect(health[:efficiency]).to be_a(Hash)
+    end
+
+    it "analyzes memory distribution" do
+      buckets_by_memory = MudisQL.metrics.buckets
+        .order(:memory_bytes, :desc)
+        .pluck(:index, :memory_bytes)
+
+      expect(buckets_by_memory).to be_an(Array)
+      expect(buckets_by_memory).not_to be_empty
+    end
+  end
+
+  describe "edge cases" do
+    it "handles empty cache" do
+      Mudis.reset!
+      Mudis.reset_metrics!
+
+      metrics = MudisQL.metrics
+
+      expect(metrics.total_keys).to eq(0)
+      expect(metrics.hit_rate).to eq(0.0)
+      expect(metrics.never_accessed_keys).to be_an(Array)
+    end
+
+    it "handles metrics without least_touched data" do
+      allow(Mudis).to receive(:metrics).and_return({
+        hits: 10,
+        misses: 5,
+        buckets: []
+      })
+
+      metrics = MudisQL.metrics
+
+      expect { metrics.least_touched.all }.not_to raise_error
+      expect { metrics.never_accessed_keys }.not_to raise_error
+    end
+  end
+end
+

data/spec/mudis-ql/performance_spec.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+RSpec.describe "MudisQL Performance Tests" do
+  before do
+    Mudis.serializer = JSON
+  end
+
+  describe "query optimization" do
+    let(:namespace) { "perf_test" }
+
+    before do
+      # Create 1000 records
+      1000.times do |i|
+        Mudis.write(
+          "record_#{i}",
+          {
+            id: i,
+            category: ["A", "B", "C", "D", "E"][i % 5],
+            score: rand(1..100),
+            active: i.even?,
+            name: "Record #{i}"
+          },
+          namespace: namespace
+        )
+      end
+    end
+
+    it "executes complex queries efficiently" do
+      start_time = Time.now
+
+      results = MudisQL.from(namespace)
+        .where(category: "A")
+        .where(score: ->(s) { s > 50 })
+        .where(active: true)
+        .order(:score, :desc)
+        .limit(20)
+        .all
+
+      duration = Time.now - start_time
+
+      expect(results.size).to be <= 20
+      expect(duration).to be < 1.0 # Should complete in under 1 second
+    end
+
+    it "handles multiple sequential queries efficiently" do
+      start_time = Time.now
+
+      10.times do
+        MudisQL.from(namespace)
+          .where(active: true)
+          .order(:score)
+          .limit(10)
+          .all
+      end
+
+      duration = Time.now - start_time
+
+      expect(duration).to be < 2.0 # 10 queries in under 2 seconds
+    end
+
+    it "counts large result sets efficiently" do
+      start_time = Time.now
+
+      count = MudisQL.from(namespace)
+        .where(active: true)
+        .count
+
+      duration = Time.now - start_time
+
+      expect(count).to eq(500)
+      expect(duration).to be < 0.5
+    end
+
+    it "handles pluck on large datasets efficiently" do
+      start_time = Time.now
+
+      ids = MudisQL.from(namespace)
+        .where(category: "B")
+        .pluck(:id)
+
+      duration = Time.now - start_time
+
+      expect(ids.size).to eq(200)
+      expect(duration).to be < 0.5
+    end
+  end
+
+  describe "memory efficiency" do
+    let(:namespace) { "memory_test" }
+
+    it "handles queries without loading all data unnecessarily" do
+      100.times do |i|
+        Mudis.write("m#{i}", { value: i }, namespace: namespace)
+      end
+
+      # first should be more efficient than all.first
+      result = MudisQL.from(namespace)
+        .where(value: ->(v) { v > 50 })
+        .order(:value)
+        .first
+
+      expect(result["value"]).to eq(51)
+    end
+
+    it "handles pagination without memory bloat" do
+      500.times do |i|
+        Mudis.write("p#{i}", { seq: i }, namespace: namespace)
+      end
+
+      # Simulate pagination through large dataset
+      5.times do |page|
+        results = MudisQL.from(namespace)
+          .order(:seq)
+          .limit(10)
+          .offset(page * 10)
+          .all
+
+        expect(results.size).to eq(10)
+      end
+    end
+  end
+
+  describe "cache interaction patterns" do
+    let(:namespace) { "cache_pattern" }
+
+    it "efficiently handles repeated queries with cache hits" do
+      20.times { |i| Mudis.write("item#{i}", { value: i }, namespace: namespace) }
+
+      # Warm up
+      MudisQL.from(namespace).all
+
+      start_time = Time.now
+
+      # Run same query 100 times
+      100.times do
+        MudisQL.from(namespace)
+          .where(value: ->(v) { v < 10 })
+          .all
+      end
+
+      duration = Time.now - start_time
+
+      # Should benefit from cache, complete quickly
+      expect(duration).to be < 2.0
+    end
+
+    it "handles rapid creation and querying" do
+      start_time = Time.now
+
+      100.times do |i|
+        Mudis.write("rapid#{i}", { num: i }, namespace: namespace)
+        
+        # Query immediately after write
+        result = MudisQL.from(namespace)
+          .where(num: i)
+          .first
+
+        expect(result).not_to be_nil
+      end
+
+      duration = Time.now - start_time
+
+      expect(duration).to be < 3.0
+    end
+  end
+
+  describe "query complexity scaling" do
+    let(:namespace) { "scaling" }
+
+    before do
+      200.times do |i|
+        Mudis.write(
+          "s#{i}",
+          {
+            a: rand(100),
+            b: rand(100),
+            c: rand(100),
+            d: ["x", "y", "z"].sample,
+            e: i.even?
+          },
+          namespace: namespace
+        )
+      end
+    end
+
+    it "handles queries with multiple conditions" do
+      start_time = Time.now
+
+      results = MudisQL.from(namespace)
+        .where(a: ->(v) { v > 25 })
+        .where(b: ->(v) { v < 75 })
+        .where(c: 40..60)
+        .where(d: "x")
+        .where(e: true)
+        .all
+
+      duration = Time.now - start_time
+
+      expect(duration).to be < 0.5
+      expect(results).to be_an(Array)
+    end
+
+    it "handles complex ordering scenarios" do
+      start_time = Time.now
+
+      results = MudisQL.from(namespace)
+        .where(a: ->(v) { v > 50 })
+        .order(:b, :desc)
+        .limit(50)
+        .all
+
+      duration = Time.now - start_time
+
+      expect(duration).to be < 0.5
+      expect(results.size).to be <= 50
+    end
+  end
+
+  describe "real-world simulation" do
+    it "simulates an e-commerce search with filters" do
+      # Setup product catalog
+      500.times do |i|
+        Mudis.write(
+          "product_#{i}",
+          {
+            name: "Product #{i}",
+            price: rand(10..1000),
+            category: ["Electronics", "Clothing", "Home", "Sports"][i % 4],
+            rating: rand(1.0..5.0).round(1),
+            in_stock: [true, false].sample,
+            brand: ["BrandA", "BrandB", "BrandC"][i % 3]
+          },
+          namespace: "products"
+        )
+      end
+
+      # Simulate user search
+      start_time = Time.now
+
+      results = MudisQL.from("products")
+        .where(category: "Electronics")
+        .where(price: 100..500)
+        .where(rating: ->(r) { r >= 4.0 })
+        .where(in_stock: true)
+        .order(:price, :asc)
+        .limit(25)
+        .all
+
+      duration = Time.now - start_time
+
+      expect(results.size).to be <= 25
+      expect(duration).to be < 0.8
+    end
+
+    it "simulates user analytics dashboard" do
+      # Setup user data
+      300.times do |i|
+        Mudis.write(
+          "user_#{i}",
+          {
+            id: i,
+            signup_date: "2025-#{rand(1..12).to_s.rjust(2, '0')}-01",
+            lifetime_value: rand(0..5000),
+            orders: rand(0..50),
+            status: ["active", "inactive", "suspended"][i % 3]
+          },
+          namespace: "users"
+        )
+      end
+
+      start_time = Time.now
+
+      # Dashboard queries
+      active_users = MudisQL.from("users").where(status: "active").count
+      high_value = MudisQL.from("users")
+        .where(lifetime_value: ->(v) { v > 1000 })
+        .where(status: "active")
+        .count
+      
+      top_customers = MudisQL.from("users")
+        .where(status: "active")
+        .order(:lifetime_value, :desc)
+        .limit(10)
+        .pluck(:id, :lifetime_value)
+
+      duration = Time.now - start_time
+
+      expect(active_users).to be > 0
+      expect(high_value).to be >= 0
+      expect(top_customers.size).to eq(10)
+      expect(duration).to be < 1.0
+    end
+  end
+end
+