mudis-ql 0.1.0

data/spec/mudis-ql/error_handling_spec.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+RSpec.describe "MudisQL Error Handling and Edge Cases" do
+  before do
+    Mudis.serializer = JSON
+  end
+
+  describe "invalid namespace scenarios" do
+    it "handles empty namespace gracefully" do
+      store = MudisQL::Store.new("")
+      expect { store.all }.not_to raise_error
+      expect(store.all).to eq([])
+    end
+
+    it "handles non-existent namespace" do
+      results = MudisQL.from("nonexistent_namespace_12345").all
+      expect(results).to eq([])
+    end
+
+    it "handles querying for non-existent key in existing namespace" do
+      namespace = "existing_namespace_test"
+      Mudis.write("key1", { name: "Alice" }, namespace: namespace)
+      Mudis.write("key2", { name: "Bob" }, namespace: namespace)
+
+      # Query for a key that doesn't exist using _key field
+      results = MudisQL.from(namespace).where(_key: "nonexistent_key").all
+      expect(results).to eq([])
+
+      # Verify the namespace itself has data
+      all_results = MudisQL.from(namespace).all
+      expect(all_results.size).to eq(2)
+    end
+  end
+
+  describe "malformed data scenarios" do
+    let(:namespace) { "malformed_test" }
+
+    it "handles non-hash values in cache" do
+      Mudis.write("string", "just a string", namespace: namespace)
+      Mudis.write("number", 42, namespace: namespace)
+      Mudis.write("array", [1, 2, 3], namespace: namespace)
+
+      results = MudisQL.from(namespace).all
+
+      expect(results.size).to eq(3)
+      expect(results.find { |r| r["_key"] == "string" }["value"]).to eq("just a string")
+      expect(results.find { |r| r["_key"] == "number" }["value"]).to eq(42)
+    end
+
+    it "handles mixed hash and non-hash values" do
+      Mudis.write("obj1", { name: "Object" }, namespace: namespace)
+      Mudis.write("str1", "String value", namespace: namespace)
+
+      results = MudisQL.from(namespace).all
+
+      expect(results.size).to eq(2)
+      obj = results.find { |r| r["_key"] == "obj1" }
+      str = results.find { |r| r["_key"] == "str1" }
+
+      expect(obj).to have_key("name")
+      expect(str).to have_key("value")
+    end
+  end
+
+  describe "query condition edge cases" do
+    let(:namespace) { "edge_query" }
+
+    before do
+      Mudis.write("1", { value: 10, name: "Ten" }, namespace: namespace)
+      Mudis.write("2", { value: 20, name: "Twenty" }, namespace: namespace)
+    end
+
+    it "handles condition on non-existent field" do
+      results = MudisQL.from(namespace)
+        .where(nonexistent_field: "value")
+        .all
+
+      expect(results).to be_empty
+    end
+
+    it "handles proc that raises exception gracefully" do
+      # Proc that would error on nil
+      expect {
+        MudisQL.from(namespace)
+          .where(value: ->(v) { v.to_s.upcase })
+          .all
+      }.not_to raise_error
+    end
+
+    it "handles regex on non-string fields" do
+      results = MudisQL.from(namespace)
+        .where(value: /10/)
+        .all
+
+      # Should convert to string and match
+      expect(results.size).to eq(1)
+    end
+
+    it "handles range comparisons with incompatible types" do
+      Mudis.write("3", { value: "string" }, namespace: namespace)
+
+      # Should not crash when range comparison fails
+      expect {
+        MudisQL.from(namespace)
+          .where(value: 15..25)
+          .all
+      }.not_to raise_error
+    end
+  end
+
+  describe "ordering edge cases" do
+    let(:namespace) { "order_edge" }
+
+    before do
+      Mudis.write("1", { name: "Alpha", score: 10 }, namespace: namespace)
+      Mudis.write("2", { name: "Beta", score: nil }, namespace: namespace)
+      Mudis.write("3", { name: "Gamma", score: 5 }, namespace: namespace)
+      Mudis.write("4", { name: nil, score: 15 }, namespace: namespace)
+    end
+
+    it "orders with nil values ascending" do
+      results = MudisQL.from(namespace)
+        .order(:score, :asc)
+        .pluck(:name, :score)
+
+      # Nil should be at the end
+      expect(results.last[1]).to be_nil
+    end
+
+    it "orders with nil values descending" do
+      results = MudisQL.from(namespace)
+        .order(:score, :desc)
+        .pluck(:name, :score)
+
+      # Nil should be at the end (in desc, that's still last)
+      expect(results.last[1]).to be_nil
+    end
+
+    it "orders by non-existent field" do
+      results = MudisQL.from(namespace)
+        .order(:nonexistent)
+        .all
+
+      # Should not crash, order may be arbitrary
+      expect(results.size).to eq(4)
+    end
+
+    it "orders strings and numbers in same field" do
+      Mudis.write("5", { mixed: "zebra" }, namespace: namespace)
+      Mudis.write("6", { mixed: 100 }, namespace: namespace)
+
+      expect {
+        MudisQL.from(namespace)
+          .order(:mixed)
+          .all
+      }.not_to raise_error
+    end
+  end
+
+  describe "pagination edge cases" do
+    let(:namespace) { "pagination_edge" }
+
+    before do
+      5.times { |i| Mudis.write("item#{i}", { value: i }, namespace: namespace) }
+    end
+
+    it "handles offset larger than result set" do
+      results = MudisQL.from(namespace)
+        .offset(100)
+        .all
+
+      expect(results).to be_empty
+    end
+
+    it "handles limit of 0" do
+      results = MudisQL.from(namespace)
+        .limit(0)
+        .all
+
+      expect(results).to be_empty
+    end
+
+    it "handles negative offset (should treat as 0)" do
+      results = MudisQL.from(namespace)
+        .offset(-5)
+        .all
+
+      # Should return all items
+      expect(results.size).to eq(5)
+    end
+
+    it "handles very large limit" do
+      results = MudisQL.from(namespace)
+        .limit(1_000_000)
+        .all
+
+      # Should return all available items
+      expect(results.size).to eq(5)
+    end
+  end
+
+  describe "pluck edge cases" do
+    let(:namespace) { "pluck_edge" }
+
+    before do
+      Mudis.write("1", { a: 1, b: 2, c: 3 }, namespace: namespace)
+      Mudis.write("2", { a: 4, b: nil, c: 6 }, namespace: namespace)
+    end
+
+    it "plucks non-existent fields" do
+      results = MudisQL.from(namespace).pluck(:nonexistent)
+
+      expect(results).to eq([nil, nil])
+    end
+
+    it "plucks with mixed existent and non-existent fields" do
+      results = MudisQL.from(namespace).pluck(:a, :nonexistent)
+
+      expect(results).to contain_exactly([1, nil], [4, nil])
+    end
+
+    it "plucks no fields" do
+      results = MudisQL.from(namespace).pluck
+
+      expect(results.size).to eq(2)
+      expect(results.first).to eq([])
+    end
+
+    it "plucks with nil values" do
+      results = MudisQL.from(namespace).pluck(:b)
+
+      expect(results).to contain_exactly(2, nil)
+    end
+  end
+
+  describe "chaining and scope state" do
+    let(:namespace) { "chain_test" }
+
+    before do
+      3.times { |i| Mudis.write("i#{i}", { value: i * 10 }, namespace: namespace) }
+    end
+
+    it "maintains independent scope chains" do
+      # Create fresh scopes for each test
+      scope1 = MudisQL.from(namespace).where(value: 0)
+      count1 = scope1.count
+      
+      scope2 = MudisQL.from(namespace).where(value: 10)
+      count2 = scope2.count
+
+      expect(count1).to eq(1)
+      expect(count2).to eq(1)
+      # Verify scope1 is still independent
+      expect(scope1.count).to eq(1)
+    end
+
+    it "allows multiple calls to same method" do
+      results = MudisQL.from(namespace)
+        .where(value: ->(v) { v >= 0 })
+        .where(value: ->(v) { v <= 20 })
+        .all
+
+      expect(results.size).to eq(3)
+    end
+
+    it "order can be called multiple times (last wins)" do
+      results = MudisQL.from(namespace)
+        .order(:value, :asc)
+        .order(:value, :desc)
+        .pluck(:value)
+
+      expect(results.first).to be > results.last
+    end
+  end
+
+  describe "concurrent access scenarios" do
+    let(:namespace) { "concurrent" }
+
+    it "handles modifications during query execution" do
+      10.times { |i| Mudis.write("i#{i}", { value: i }, namespace: namespace) }
+
+      # Start a query
+      query = MudisQL.from(namespace).where(value: ->(v) { v < 5 })
+      
+      # Modify data before executing
+      Mudis.write("i11", { value: 2 }, namespace: namespace)
+      
+      results = query.all
+
+      # Should still execute without error
+      expect(results).to be_an(Array)
+    end
+  end
+
+  describe "type coercion and comparison" do
+    let(:namespace) { "type_test" }
+
+    before do
+      Mudis.write("1", { value: "100", type: "string" }, namespace: namespace)
+      Mudis.write("2", { value: 100, type: "integer" }, namespace: namespace)
+      Mudis.write("3", { value: 100.0, type: "float" }, namespace: namespace)
+      Mudis.write("4", { value: true, type: "boolean" }, namespace: namespace)
+    end
+
+    it "handles exact matches with different types" do
+      string_results = MudisQL.from(namespace).where(value: "100").count
+      # Note: 100.0 and 100 are equal in Ruby and JSON doesn't distinguish
+      int_results = MudisQL.from(namespace).where(value: 100).count
+
+      expect(string_results).to eq(1)
+      expect(int_results).to eq(2) # Matches both integer and float
+    end
+
+    it "handles boolean values" do
+      results = MudisQL.from(namespace).where(value: true).all
+
+      expect(results.size).to eq(1)
+      expect(results.first["type"]).to eq("boolean")
+    end
+
+    it "handles proc comparisons with type flexibility" do
+      results = MudisQL.from(namespace)
+        .where(value: ->(v) { v.to_s == "100" })
+        .all
+
+      expect(results.size).to eq(2) # String "100" and integer 100 (float becomes int in JSON)
+    end
+  end
+end
+

data/spec/mudis-ql/integration_spec.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+RSpec.describe "MudisQL Integration Tests" do
+  let(:namespace) { "test_integration" }
+
+  before do
+    Mudis.serializer = JSON
+  end
+
+  describe "E-commerce product catalog scenario" do
+    before do
+      # Seed a realistic product catalog
+      products = [
+        { id: "p001", name: "MacBook Pro 16", price: 2499, category: "laptops", brand: "Apple", rating: 4.8, stock: 15, tags: ["premium", "professional"] },
+        { id: "p002", name: "Dell XPS 15", price: 1899, category: "laptops", brand: "Dell", rating: 4.6, stock: 25, tags: ["business", "professional"] },
+        { id: "p003", name: "ThinkPad X1", price: 1599, category: "laptops", brand: "Lenovo", rating: 4.7, stock: 30, tags: ["business", "durable"] },
+        { id: "p004", name: "Magic Mouse", price: 79, category: "accessories", brand: "Apple", rating: 4.2, stock: 100, tags: ["wireless"] },
+        { id: "p005", name: "Logitech MX Master", price: 99, category: "accessories", brand: "Logitech", rating: 4.9, stock: 75, tags: ["wireless", "ergonomic"] },
+        { id: "p006", name: "iPad Pro 12.9", price: 1099, category: "tablets", brand: "Apple", rating: 4.8, stock: 40, tags: ["premium", "creative"] },
+        { id: "p007", name: "Surface Pro 9", price: 999, category: "tablets", brand: "Microsoft", rating: 4.5, stock: 35, tags: ["business", "versatile"] },
+        { id: "p008", name: "AirPods Pro", price: 249, category: "accessories", brand: "Apple", rating: 4.7, stock: 200, tags: ["wireless", "premium"] },
+        { id: "p009", name: "Samsung Galaxy Tab", price: 449, category: "tablets", brand: "Samsung", rating: 4.4, stock: 50, tags: ["android", "affordable"] },
+        { id: "p010", name: "Mechanical Keyboard", price: 159, category: "accessories", brand: "Keychron", rating: 4.6, stock: 45, tags: ["mechanical", "rgb"] }
+      ]
+
+      products.each do |product|
+        Mudis.write(product[:id], product, namespace: namespace, expires_in: 3600)
+      end
+    end
+
+    it "finds premium Apple products over $1000" do
+      results = MudisQL.from(namespace)
+        .where(brand: "Apple")
+        .where(price: ->(p) { p > 1000 })
+        .order(:price, :desc)
+        .all
+
+      expect(results.size).to eq(2)
+      expect(results[0]["name"]).to eq("MacBook Pro 16")
+      expect(results[1]["name"]).to eq("iPad Pro 12.9")
+    end
+
+    it "finds highly rated products (>4.5) with good stock" do
+      results = MudisQL.from(namespace)
+        .where(rating: ->(r) { r > 4.5 })
+        .where(stock: ->(s) { s >= 30 })
+        .order(:rating, :desc)
+        .pluck(:name, :rating, :stock)
+
+      expect(results.size).to eq(5)
+      expect(results.first).to eq(["Logitech MX Master", 4.9, 75])
+    end
+
+    it "paginates through laptop results" do
+      page1 = MudisQL.from(namespace)
+        .where(category: "laptops")
+        .order(:price)
+        .limit(2)
+        .offset(0)
+        .all
+
+      page2 = MudisQL.from(namespace)
+        .where(category: "laptops")
+        .order(:price)
+        .limit(2)
+        .offset(2)
+        .all
+
+      expect(page1.map { |p| p["name"] }).to eq(["ThinkPad X1", "Dell XPS 15"])
+      expect(page2.map { |p| p["name"] }).to eq(["MacBook Pro 16"])
+    end
+
+    it "finds products in price range with specific brand" do
+      results = MudisQL.from(namespace)
+        .where(price: 100..1000)
+        .where(brand: /^(Apple|Microsoft)$/i)
+        .order(:price)
+        .all
+
+      expect(results.map { |p| p["name"] }).to eq(["AirPods Pro", "Surface Pro 9"])
+    end
+
+    it "gets product count by category" do
+      laptop_count = MudisQL.from(namespace).where(category: "laptops").count
+      accessory_count = MudisQL.from(namespace).where(category: "accessories").count
+      tablet_count = MudisQL.from(namespace).where(category: "tablets").count
+
+      expect(laptop_count).to eq(3)
+      expect(accessory_count).to eq(4)
+      expect(tablet_count).to eq(3)
+    end
+  end
+
+  describe "User analytics scenario" do
+    before do
+      # Seed user activity data
+      users = [
+        { id: "u001", name: "Alice", email: "alice@example.com", status: "active", last_login_days: 2, orders: 15, lifetime_value: 2500 },
+        { id: "u002", name: "Bob", email: "bob@example.com", status: "active", last_login_days: 1, orders: 8, lifetime_value: 800 },
+        { id: "u003", name: "Charlie", email: "charlie@example.com", status: "inactive", last_login_days: 45, orders: 3, lifetime_value: 150 },
+        { id: "u004", name: "Diana", email: "diana@example.com", status: "active", last_login_days: 5, orders: 25, lifetime_value: 4200 },
+        { id: "u005", name: "Eve", email: "eve@example.com", status: "suspended", last_login_days: 120, orders: 1, lifetime_value: 50 },
+        { id: "u006", name: "Frank", email: "frank@example.com", status: "active", last_login_days: 3, orders: 12, lifetime_value: 1800 },
+        { id: "u007", name: "Grace", email: "grace@example.com", status: "inactive", last_login_days: 60, orders: 0, lifetime_value: 0 }
+      ]
+
+      users.each do |user|
+        Mudis.write(user[:id], user, namespace: "users", expires_in: 1800)
+      end
+    end
+
+    it "identifies VIP customers (high value, active)" do
+      vips = MudisQL.from("users")
+        .where(status: "active")
+        .where(lifetime_value: ->(v) { v >= 2000 })
+        .order(:lifetime_value, :desc)
+        .all
+
+      expect(vips.size).to eq(2)
+      expect(vips.map { |u| u["name"] }).to eq(["Diana", "Alice"])
+    end
+
+    it "finds at-risk users (active but haven't logged in recently)" do
+      at_risk = MudisQL.from("users")
+        .where(status: "active")
+        .where(last_login_days: ->(d) { d > 4 })
+        .pluck(:name, :last_login_days, :orders)
+
+      expect(at_risk.size).to eq(1)
+      expect(at_risk.first[0]).to eq("Diana")
+    end
+
+    it "segments users by engagement level" do
+      high_engagement = MudisQL.from("users")
+        .where(orders: ->(o) { o >= 10 })
+        .where(status: "active")
+        .count
+
+      low_engagement = MudisQL.from("users")
+        .where(orders: ->(o) { o < 5 })
+        .where(status: "active")
+        .count
+
+      expect(high_engagement).to eq(3)
+      expect(low_engagement).to eq(0) # Bob has 8 orders, so no active users with < 5 orders
+    end
+
+    it "finds reactivation candidates" do
+      candidates = MudisQL.from("users")
+        .where(status: "inactive")
+        .where(orders: ->(o) { o > 0 })
+        .where(lifetime_value: ->(v) { v > 100 })
+        .order(:last_login_days)
+        .all
+
+      expect(candidates.size).to eq(1)
+      expect(candidates.first["name"]).to eq("Charlie")
+    end
+  end
+
+  describe "Complex query combinations" do
+    before do
+      # Mixed data types
+      data = [
+        { id: "1", name: "Alpha", score: 95, tags: ["premium"], created_at: "2025-01-01" },
+        { id: "2", name: "Beta", score: 82, tags: ["standard"], created_at: "2025-01-15" },
+        { id: "3", name: "Gamma", score: 78, tags: ["premium", "featured"], created_at: "2025-02-01" },
+        { id: "4", name: "Delta", score: 91, tags: ["standard"], created_at: "2025-01-20" },
+        { id: "5", name: "Epsilon", score: 88, tags: ["featured"], created_at: "2025-02-10" }
+      ]
+
+      data.each { |d| Mudis.write(d[:id], d, namespace: "items") }
+    end
+
+    it "handles multiple regex patterns" do
+      results = MudisQL.from("items")
+        .where(name: /^[AE]/)
+        .where(score: ->(s) { s > 85 })
+        .all
+
+      expect(results.map { |r| r["name"] }).to contain_exactly("Alpha", "Epsilon")
+    end
+
+    it "combines ranges with other conditions" do
+      results = MudisQL.from("items")
+        .where(score: 80..90)
+        .where(name: ->(n) { n.length > 5 })  # Changed to > 5 to exclude "Delta"
+        .order(:score, :desc)
+        .all
+
+      expect(results.map { |r| r["name"] }).to eq(["Epsilon"])
+    end
+
+    it "handles empty result sets gracefully" do
+      results = MudisQL.from("items")
+        .where(score: ->(s) { s > 100 })
+        .all
+
+      expect(results).to be_empty
+      expect(MudisQL.from("items").where(score: 999).exists?).to be false
+      expect(MudisQL.from("items").where(score: 999).count).to eq(0)
+      expect(MudisQL.from("items").where(score: 999).first).to be_nil
+    end
+
+    it "plucks multiple fields with complex queries" do
+      results = MudisQL.from("items")
+        .where(score: ->(s) { s >= 85 })
+        .order(:score, :desc)
+        .pluck(:name, :score, :tags)
+
+      expect(results.size).to eq(3)
+      expect(results.first[0]).to eq("Alpha")
+      expect(results.first[1]).to eq(95)
+    end
+  end
+
+  describe "Edge cases and nil handling" do
+    before do
+      data = [
+        { id: "1", name: "Complete", value: 100, status: "active", metadata: { key: "val" } },
+        { id: "2", name: nil, value: 50, status: "pending", metadata: nil },
+        { id: "3", name: "Partial", value: nil, status: "active", metadata: { key: "val" } },
+        { id: "4", name: "", value: 0, status: nil, metadata: {} }
+      ]
+
+      data.each { |d| Mudis.write(d[:id], d, namespace: "edge_cases") }
+    end
+
+    it "handles nil values in comparisons" do
+      results = MudisQL.from("edge_cases")
+        .where(status: "active")
+        .all
+
+      expect(results.size).to eq(2)
+    end
+
+    it "handles nil values in ordering" do
+      results = MudisQL.from("edge_cases")
+        .order(:value)
+        .pluck(:id, :value)
+
+      # Nil values should be pushed to end
+      expect(results.last[1]).to be_nil
+    end
+
+    it "handles proc conditions with nil values" do
+      results = MudisQL.from("edge_cases")
+        .where(value: ->(v) { !v.nil? && v > 0 })
+        .all
+
+      expect(results.size).to eq(2)
+      expect(results.map { |r| r["id"] }).to contain_exactly("1", "2")
+    end
+
+    it "handles empty strings" do
+      results = MudisQL.from("edge_cases")
+        .where(name: "")
+        .all
+
+      expect(results.size).to eq(1)
+      expect(results.first["id"]).to eq("4")
+    end
+  end
+
+  describe "Performance and scale tests" do
+    it "handles larger datasets efficiently" do
+      # Create 100 records
+      100.times do |i|
+        Mudis.write(
+          "item_#{i}",
+          { id: i, value: rand(1..1000), category: ["A", "B", "C"].sample },
+          namespace: "large_set"
+        )
+      end
+
+      # Complex query
+      results = MudisQL.from("large_set")
+        .where(category: "A")
+        .where(value: ->(v) { v > 500 })
+        .order(:value, :desc)
+        .limit(10)
+        .all
+
+      expect(results.size).to be <= 10
+      expect(results).to all(have_key("category"))
+    end
+
+    it "handles rapid consecutive queries" do
+      Mudis.write("test1", { value: 1 }, namespace: "rapid")
+      Mudis.write("test2", { value: 2 }, namespace: "rapid")
+
+      10.times do
+        result = MudisQL.from("rapid").where(value: 1).first
+        expect(result).not_to be_nil
+      end
+    end
+  end
+
+  describe "Scope reusability" do
+    before do
+      5.times do |i|
+        Mudis.write("p#{i}", { price: (i + 1) * 100, active: i.even? }, namespace: "products")
+      end
+    end
+
+    it "allows building reusable scope objects" do
+      # Each scope should be independent
+      cheap_active = MudisQL.from("products")
+        .where(active: true)
+        .where(price: ->(p) { p < 300 })
+        .all
+        
+      expensive_active = MudisQL.from("products")
+        .where(active: true)
+        .where(price: ->(p) { p >= 300 })
+        .all
+
+      # With 5 products at 100, 200, 300, 400, 500
+      # Active are at indices 0, 2, 4 = 100, 300, 500
+      expect(cheap_active.size).to eq(1)  # 100
+      expect(expensive_active.size).to eq(2) # 300, 500
+    end
+
+    it "maintains query independence" do
+      scope1 = MudisQL.from("products")
+      scope2 = MudisQL.from("products")
+
+      scope1.where(active: true)
+      scope2.where(active: false)
+
+      # Both queries should work independently
+      expect(scope1.count).to eq(3)
+      expect(scope2.count).to eq(2)
+    end
+  end
+end
+