factbase 0.7.5 → 0.9.0

data/test/factbase/terms/test_meta.rb

@@ -12,59 +12,59 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestMeta < Factbase::Test
   def test_exists
-    t = Factbase::Term.new(Factbase.new, :exists, [:foo])
-    assert(t.evaluate(fact('foo' => 41), []))
-    refute(t.evaluate(fact('bar' => 41), []))
+    t = Factbase::Term.new(:exists, [:foo])
+    assert(t.evaluate(fact('foo' => 41), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => 41), [], Factbase.new))
   end
 
   def test_absent
-    t = Factbase::Term.new(Factbase.new, :absent, [:foo])
-    refute(t.evaluate(fact('foo' => 41), []))
-    assert(t.evaluate(fact('bar' => 41), []))
+    t = Factbase::Term.new(:absent, [:foo])
+    refute(t.evaluate(fact('foo' => 41), [], Factbase.new))
+    assert(t.evaluate(fact('bar' => 41), [], Factbase.new))
   end
 
   def test_size
-    t = Factbase::Term.new(Factbase.new, :size, [:foo])
-    assert_equal(1, t.evaluate(fact('foo' => 41), []))
-    assert_equal(0, t.evaluate(fact('foo' => nil), []))
-    assert_equal(4, t.evaluate(fact('foo' => [1, 2, 3, 4]), []))
-    assert_equal(0, t.evaluate(fact('foo' => []), []))
-    assert_equal(1, t.evaluate(fact('foo' => ''), []))
+    t = Factbase::Term.new(:size, [:foo])
+    assert_equal(1, t.evaluate(fact('foo' => 41), [], Factbase.new))
+    assert_equal(0, t.evaluate(fact('foo' => nil), [], Factbase.new))
+    assert_equal(4, t.evaluate(fact('foo' => [1, 2, 3, 4]), [], Factbase.new))
+    assert_equal(0, t.evaluate(fact('foo' => []), [], Factbase.new))
+    assert_equal(1, t.evaluate(fact('foo' => ''), [], Factbase.new))
   end
 
   def test_type
-    t = Factbase::Term.new(Factbase.new, :type, [:foo])
-    assert_equal('nil', t.evaluate(fact('foo' => nil), []))
-    assert_equal('Integer', t.evaluate(fact('foo' => [1]), []))
-    assert_equal('Array', t.evaluate(fact('foo' => [1, 2]), []))
-    assert_equal('String', t.evaluate(fact('foo' => 'bar'), []))
-    assert_equal('Float', t.evaluate(fact('foo' => 2.1), []))
-    assert_equal('Time', t.evaluate(fact('foo' => Time.now), []))
+    t = Factbase::Term.new(:type, [:foo])
+    assert_equal('nil', t.evaluate(fact('foo' => nil), [], Factbase.new))
+    assert_equal('Integer', t.evaluate(fact('foo' => [1]), [], Factbase.new))
+    assert_equal('Array', t.evaluate(fact('foo' => [1, 2]), [], Factbase.new))
+    assert_equal('String', t.evaluate(fact('foo' => 'bar'), [], Factbase.new))
+    assert_equal('Float', t.evaluate(fact('foo' => 2.1), [], Factbase.new))
+    assert_equal('Time', t.evaluate(fact('foo' => Time.now), [], Factbase.new))
   end
 
   def test_nil
-    t = Factbase::Term.new(Factbase.new, :nil, [:foo])
-    assert(t.evaluate(fact('foo' => nil), []))
-    refute(t.evaluate(fact('foo' => true), []))
-    refute(t.evaluate(fact('foo' => 'bar'), []))
+    t = Factbase::Term.new(:nil, [:foo])
+    assert(t.evaluate(fact('foo' => nil), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => true), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 'bar'), [], Factbase.new))
   end
 
   def test_many
-    t = Factbase::Term.new(Factbase.new, :many, [:foo])
-    refute(t.evaluate(fact('foo' => nil), []))
-    refute(t.evaluate(fact('foo' => 1), []))
-    refute(t.evaluate(fact('foo' => '1234'), []))
-    assert(t.evaluate(fact('foo' => [1, 3, 5]), []))
-    refute(t.evaluate(fact('foo' => []), []))
+    t = Factbase::Term.new(:many, [:foo])
+    refute(t.evaluate(fact('foo' => nil), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 1), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => '1234'), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [1, 3, 5]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
   end
 
   def test_one
-    t = Factbase::Term.new(Factbase.new, :one, [:foo])
-    assert(t.evaluate(fact('foo' => 1), []))
-    assert(t.evaluate(fact('foo' => '1234'), []))
-    assert(t.evaluate(fact('foo' => [1]), []))
-    refute(t.evaluate(fact('foo' => nil), []))
-    refute(t.evaluate(fact('foo' => [1, 3, 5]), []))
-    refute(t.evaluate(fact('foo' => []), []))
+    t = Factbase::Term.new(:one, [:foo])
+    assert(t.evaluate(fact('foo' => 1), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => '1234'), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [1]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => nil), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [1, 3, 5]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
   end
 end

data/test/factbase/terms/test_ordering.rb

@@ -12,17 +12,17 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestOrdering < Factbase::Test
   def test_prev
-    t = Factbase::Term.new(Factbase.new, :prev, [:foo])
-    assert_nil(t.evaluate(fact('foo' => 41), []))
-    assert_equal([41], t.evaluate(fact('foo' => 5), []))
-    assert_equal([5], t.evaluate(fact('foo' => 6), []))
+    t = Factbase::Term.new(:prev, [:foo])
+    assert_nil(t.evaluate(fact('foo' => 41), [], Factbase.new))
+    assert_equal([41], t.evaluate(fact('foo' => 5), [], Factbase.new))
+    assert_equal([5], t.evaluate(fact('foo' => 6), [], Factbase.new))
   end
 
   def test_unique
-    t = Factbase::Term.new(Factbase.new, :unique, [:foo])
-    refute(t.evaluate(fact, []))
-    assert(t.evaluate(fact('foo' => 41), []))
-    refute(t.evaluate(fact('foo' => 41), []))
-    assert(t.evaluate(fact('foo' => 1), []))
+    t = Factbase::Term.new(:unique, [:foo])
+    refute(t.evaluate(fact, [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 41), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 41), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 1), [], Factbase.new))
   end
 end

data/test/factbase/terms/test_strings.rb

@@ -12,25 +12,25 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestStrings < Factbase::Test
   def test_regexp_matching
-    t = Factbase::Term.new(Factbase.new, :matches, [:foo, '[a-z]+'])
-    assert(t.evaluate(fact('foo' => 'hello'), []))
-    assert(t.evaluate(fact('foo' => 'hello 42'), []))
-    refute(t.evaluate(fact('foo' => 42), []))
+    t = Factbase::Term.new(:matches, [:foo, '[a-z]+'])
+    assert(t.evaluate(fact('foo' => 'hello'), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 'hello 42'), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 42), [], Factbase.new))
   end
 
   def test_concat
-    t = Factbase::Term.new(Factbase.new, :concat, [42, 'hi', 3.14, :hey, Time.now])
-    s = t.evaluate(fact, [])
+    t = Factbase::Term.new(:concat, [42, 'hi', 3.14, :hey, Time.now])
+    s = t.evaluate(fact, [], Factbase.new)
     assert(s.start_with?('42hi3.14'))
   end
 
   def test_concat_empty
-    t = Factbase::Term.new(Factbase.new, :concat, [])
-    assert_equal('', t.evaluate(fact, []))
+    t = Factbase::Term.new(:concat, [])
+    assert_equal('', t.evaluate(fact, [], Factbase.new))
   end
 
   def test_sprintf
-    t = Factbase::Term.new(Factbase.new, :sprintf, ['hi, %s!', 'Jeff'])
-    assert_equal('hi, Jeff!', t.evaluate(fact, []))
+    t = Factbase::Term.new(:sprintf, ['hi, %s!', 'Jeff'])
+    assert_equal('hi, Jeff!', t.evaluate(fact, [], Factbase.new))
   end
 end

data/test/factbase/terms/test_system.rb

@@ -13,19 +13,19 @@ require_relative '../../../lib/factbase/term'
 class TestSystem < Factbase::Test
   def test_env
     ENV.store('FOO', 'bar')
-    t = Factbase::Term.new(Factbase.new, :env, ['FOO', ''])
-    assert_equal('bar', t.evaluate(fact, []))
+    t = Factbase::Term.new(:env, ['FOO', ''])
+    assert_equal('bar', t.evaluate(fact, [], Factbase.new))
   end
 
   def test_default
     ENV.delete('FOO')
-    t = Factbase::Term.new(Factbase.new, :env, ['FOO', 'мой друг'])
-    assert_equal('мой друг', t.evaluate(fact, []))
+    t = Factbase::Term.new(:env, ['FOO', 'мой друг'])
+    assert_equal('мой друг', t.evaluate(fact, [], Factbase.new))
   end
 
   def test_when_default_is_absent
     ENV.delete('FOO')
-    t = Factbase::Term.new(Factbase.new, :env, ['FOO'])
-    assert_raises(StandardError) { t.evaluate(fact, []) }
+    t = Factbase::Term.new(:env, ['FOO'])
+    assert_raises(StandardError) { t.evaluate(fact, [], Factbase.new) }
   end
 end

data/test/factbase/test_accum.rb

@@ -15,7 +15,7 @@ require_relative '../../lib/factbase/fact'
 class TestAccum < Factbase::Test
   def test_holds_props
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     props = {}
     a = Factbase::Accum.new(f, props, false)
     a.foo = 42
@@ -26,7 +26,7 @@ class TestAccum < Factbase::Test
 
   def test_passes_props
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     props = {}
     a = Factbase::Accum.new(f, props, true)
     a.foo = 42
@@ -37,7 +37,7 @@ class TestAccum < Factbase::Test
 
   def test_appends_props
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     f.foo = 42
     props = {}
     a = Factbase::Accum.new(f, props, false)
@@ -46,14 +46,14 @@ class TestAccum < Factbase::Test
   end
 
   def test_empties
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     a = Factbase::Accum.new(f, {}, false)
     assert_nil(a['foo'])
   end
 
   def test_prints_to_string
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     props = {}
     a = Factbase::Accum.new(f, props, true)
     a.foo = 42

data/test/factbase/test_fact.rb

@@ -14,7 +14,7 @@ require_relative '../../lib/factbase/fact'
 class TestFact < Factbase::Test
   def test_injects_data_correctly
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     f.foo = 1
     f.bar = 2
     f.bar = 3
@@ -25,7 +25,7 @@ class TestFact < Factbase::Test
 
   def test_simple_resetting
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     f.foo = 42
     assert_equal(42, f.foo, f.to_s)
     f.foo = 256
@@ -35,7 +35,7 @@ class TestFact < Factbase::Test
 
   def test_keeps_values_unique
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     f.foo = 42
     f.foo = 'Hello'
     assert_equal(2, map['foo'].size)
@@ -44,28 +44,28 @@ class TestFact < Factbase::Test
   end
 
   def test_fails_when_empty
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     assert_raises(StandardError) do
       f.something
     end
   end
 
   def test_fails_when_setting_nil
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     assert_raises(StandardError) do
       f.foo = nil
     end
   end
 
   def test_fails_when_setting_empty
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     assert_raises(StandardError) do
       f.foo = ''
     end
   end
 
   def test_fails_when_not_found
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     f.first = 42
     assert_raises(StandardError) do
       f.second
@@ -73,21 +73,21 @@ class TestFact < Factbase::Test
   end
 
   def test_set_by_name
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     f.send(:_foo_bar=, 42)
     assert_equal(42, f._foo_bar, f.to_s)
   end
 
   def test_set_twice_same_value
     map = {}
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    f = Factbase::Fact.new(map)
     f.foo = 42
     f.foo = 42
     assert_equal([42], map['foo'])
   end
 
   def test_time_in_utc
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     t = Time.now
     f.foo = t
     assert_equal(t.utc, f.foo)
@@ -95,13 +95,13 @@ class TestFact < Factbase::Test
   end
 
   def test_some_names_are_prohibited
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     assert_raises(StandardError) { f.to_s = 42 }
     assert_raises(StandardError) { f.class = 42 }
   end
 
   def test_get_all_properties
-    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f = Factbase::Fact.new({})
     f.foo = 42
     assert_includes(f.all_properties, 'foo')
   end

data/test/factbase/test_logged.rb

@@ -48,6 +48,13 @@ class TestLogged < Factbase::Test
     assert_includes(log.to_s, 'touched', log)
   end
 
+  def test_with_slow_txn
+    log = Loog::Buffer.new
+    fb = Factbase::Logged.new(Factbase.new, log, time_tolerate: 0.1)
+    fb.txn { sleep 0.4 }
+    assert_includes(log.to_s, '(slow!)', log)
+  end
+
   def test_with_txn_rollback
     log = Loog::Buffer.new
     fb = Factbase::Logged.new(Factbase.new, log)

data/test/factbase/test_query.rb

@@ -7,16 +7,56 @@ require_relative '../test__helper'
 require 'time'
 require_relative '../../lib/factbase'
 require_relative '../../lib/factbase/query'
+require_relative '../../lib/factbase/cached/cached_factbase'
+require_relative '../../lib/factbase/indexed/indexed_factbase'
+require_relative '../../lib/factbase/sync/sync_factbase'
 
 # Query test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestQuery < Factbase::Test
+  def test_stories
+    with_factbases do |badge, fb|
+      Dir[File.join(__dir__, '../../fixtures/stories/**/*.yml')].each do |fixture|
+        base = File.basename(fixture)
+        story = YAML.load_file(fixture)
+        2.times do
+          fb.query('(always)').delete!
+          story['facts'].each do |y|
+            f = fb.insert
+            y.each do |k, vv|
+              vv = [vv] unless vv.is_a?(Array)
+              vv.each do |v|
+                f.send(:"#{k}=", v)
+              end
+            end
+          end
+          story['queries'].each do |q|
+            qry = q['query']
+            if q['size']
+              size = q['size']
+              assert_equal(size, fb.query(qry).each.to_a.size, "#{base}: #{qry} at #{badge}")
+              fb.txn do |fbt|
+                assert_equal(size, fbt.query(qry).each.to_a.size, "#{base}: #{qry} at #{badge} (in txn)")
+              end
+            else
+              ret = q['one']
+              assert_equal(ret, fb.query(qry).one, "#{base}: #{qry} at #{badge}")
+              fb.txn do |fbt|
+                assert_equal(ret, fbt.query(qry).one, "#{base}: #{qry} at #{badge} (in txn)")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
   def test_simple_parsing
     maps = []
     maps << { 'foo' => [42] }
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo 42)')
+    q = Factbase::Query.new(maps, '(eq foo 42)', Factbase.new)
     assert_equal(
       1,
       q.each do |f|
@@ -26,12 +66,7 @@ class TestQuery < Factbase::Test
   end
 
   def test_complex_parsing
-    maps = [
-      { 'num' => [42], 'name' => ['Jeff'] },
-      { 'pi' => [3.14], 'num' => [42, 66, 0], 'name' => ['peter'] },
-      { 'time' => [Time.now - 100], 'num' => [0], 'hi' => [4], 'nome' => ['Walter'] }
-    ]
-    {
+    queries = {
       '(eq num 444)' => 0,
       '(eq hi 4)' => 1,
       '(eq time 0)' => 0,
@@ -71,11 +106,18 @@ class TestQuery < Factbase::Test
       '(undef something)' => 3,
       "(or (eq num +66) (lt time #{(Time.now - 200).utc.iso8601}))" => 1,
       '(eq 3 (agg (eq num $num) (count)))' => 1
-    }.each do |q, r|
-      fb = Factbase.new(maps)
-      assert_equal(r, fb.query(q).each.to_a.size, q)
-      fb.txn do |fbt|
-        assert_equal(r, fbt.query(q).each.to_a.size, q)
+    }
+    maps = [
+      { 'num' => [42], 'name' => ['Jeff'] },
+      { 'num' => [42, 66, 0], 'pi' => [3.14], 'name' => ['peter'] },
+      { 'num' => [0], 'time' => [Time.now - 100], 'hi' => [4], 'nome' => ['Walter'] }
+    ]
+    with_factbases(maps) do |badge, fb|
+      queries.each do |q, r|
+        assert_equal(r, fb.query(q).each.to_a.size, "#{q} in #{badge}")
+        fb.txn do |fbt|
+          assert_equal(r, fbt.query(q).each.to_a.size, "#{q} in #{badge} (txn)")
+        end
       end
     end
   end
@@ -84,7 +126,7 @@ class TestQuery < Factbase::Test
     maps = []
     now = Time.now.utc
     maps << { 'foo' => [now] }
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, "(eq foo #{now.iso8601})")
+    q = Factbase::Query.new(maps, "(eq foo #{now.iso8601})", Factbase.new)
     assert_equal(1, q.each.to_a.size)
   end
 
@@ -94,7 +136,7 @@ class TestQuery < Factbase::Test
       { 'bar' => [4, 5] },
       { 'bar' => [5] }
     ]
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq bar 5)')
+    q = Factbase::Query.new(maps, '(eq bar 5)', Factbase.new)
     assert_equal(2, q.delete!)
     assert_equal(1, maps.size)
   end
@@ -104,18 +146,20 @@ class TestQuery < Factbase::Test
       { 'foo' => [42] },
       { 'bar' => [4, 5] }
     ]
-    {
-      '(agg (exists foo) (first foo))' => [42],
-      '(agg (exists z) (first z))' => nil,
-      '(agg (always) (count))' => 2,
-      '(agg (eq bar $v) (count))' => 1,
-      '(agg (eq z 40) (count))' => 0
-    }.each do |q, expected|
-      result = Factbase::Query.new(Factbase.new, maps, Mutex.new, q).one(v: 4)
-      if expected.nil?
-        assert_nil(result, "#{q} -> nil")
-      else
-        assert_equal(expected, result, "#{q} -> #{expected}")
+    with_factbases(maps) do |badge, fb|
+      {
+        '(agg (exists foo) (first foo))' => [42],
+        '(agg (exists z) (first z))' => nil,
+        '(agg (always) (count))' => 2,
+        '(agg (eq bar $v) (count))' => 1,
+        '(agg (eq z 40) (count))' => 0
+      }.each do |q, expected|
+        result = fb.query(q).one(fb, v: 4)
+        if expected.nil?
+          assert_nil(result, "#{q} -> nil in #{badge}")
+        else
+          assert_equal(expected, result, "#{q} -> #{expected} in #{badge}")
+        end
       end
     end
   end
@@ -126,28 +170,30 @@ class TestQuery < Factbase::Test
       { 'bar' => [4, 5] },
       { 'bar' => [5] }
     ]
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(never)')
-    assert_equal(0, q.delete!)
-    assert_equal(3, maps.size)
+    with_factbases(maps) do |badge, fb|
+      q = fb.query('(never)')
+      assert_equal(0, q.delete!, "#{q} in #{badge}")
+      assert_equal(3, maps.size, "#{q} in #{badge}")
+    end
   end
 
   def test_to_array
     maps = []
     maps << { 'foo' => [42] }
-    assert_equal(1, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo 42)').each.to_a.size)
+    assert_equal(1, Factbase::Query.new(maps, '(eq foo 42)', Factbase.new).each.to_a.size)
   end
 
   def test_returns_int
     maps = []
     maps << { 'foo' => [1] }
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo 1)')
+    q = Factbase::Query.new(maps, '(eq foo 1)', Factbase.new)
     assert_equal(1, q.each(&:to_s))
   end
 
   def test_with_aliases
     maps = []
     maps << { 'foo' => [42] }
-    assert_equal(45, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(as bar (plus foo 3))').each.to_a[0].bar)
+    assert_equal(45, Factbase::Query.new(maps, '(as bar (plus foo 3))', Factbase.new).each.to_a[0].bar)
     assert_equal(1, maps[0].size)
   end
 
@@ -157,22 +203,38 @@ class TestQuery < Factbase::Test
       { 'foo' => [17] }
     ]
     found = 0
-    Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo $bar)').each(bar: [42]) do
+    Factbase::Query.new(maps, '(eq foo $bar)', Factbase.new).each(Factbase.new, bar: [42]) do
       found += 1
     end
     assert_equal(1, found)
-    assert_equal(1, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo $bar)').each(bar: 42).to_a.size)
-    assert_equal(0, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo $bar)').each(bar: 555).to_a.size)
+    assert_equal(1, Factbase::Query.new(maps, '(eq foo $bar)', Factbase.new).each(Factbase.new, bar: 42).to_a.size)
+    assert_equal(0, Factbase::Query.new(maps, '(eq foo $bar)', Factbase.new).each(Factbase.new, bar: 555).to_a.size)
   end
 
   def test_with_nil_alias
     maps = [{ 'foo' => [42] }]
-    assert_nil(Factbase::Query.new(Factbase.new, maps, Mutex.new, '(as bar (plus xxx 3))').each.to_a[0]['bar'])
+    assert_nil(Factbase::Query.new(maps, '(as bar (plus xxx 3))', Factbase.new).each.to_a[0]['bar'])
   end
 
   def test_get_all_properties
     maps = [{ 'foo' => [42] }]
-    f = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(always)').each.to_a[0]
+    f = Factbase::Query.new(maps, '(always)', Factbase.new).each.to_a[0]
     assert_includes(f.all_properties, 'foo')
   end
+
+  private
+
+  def with_factbases(maps = [], &)
+    {
+      'plain' => Factbase.new(maps),
+      'sync+plain' => Factbase::SyncFactbase.new(Factbase.new(maps)),
+      'indexed+plain' => Factbase::IndexedFactbase.new(Factbase.new(maps)),
+      'cached+plain' => Factbase::CachedFactbase.new(Factbase.new(maps)),
+      'indexed+cached+plain' => Factbase::IndexedFactbase.new(Factbase::CachedFactbase.new(Factbase.new(maps))),
+      'cached+indexed+plain' => Factbase::CachedFactbase.new(Factbase::IndexedFactbase.new(Factbase.new(maps))),
+      'sync+cached+indexed+plain' => Factbase::SyncFactbase.new(
+        Factbase::CachedFactbase.new(Factbase::IndexedFactbase.new(Factbase.new(maps)))
+      )
+    }.each(&)
+  end
 end

data/test/factbase/test_rules.rb

@@ -51,7 +51,7 @@ class TestRules < Factbase::Test
     fb = Factbase::Rules.new(Factbase.new, '(always)')
     f = fb.insert
     f.foo = 42
-    assert_equal(1, fb.query('(agg (eq foo $v) (count))').one(v: 42))
+    assert_equal(1, fb.query('(agg (eq foo $v) (count))').one(Factbase.new, v: 42))
   end
 
   def test_check_only_when_txn_is_closed