factbase 0.8.0 → 0.9.1

data/test/factbase/terms/test_math.rb

@@ -12,109 +12,111 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestMath < Factbase::Test
   def test_simple
-    t = Factbase::Term.new(Factbase.new, :eq, [:foo, 42])
-    assert(t.evaluate(fact('foo' => [42]), []))
-    refute(t.evaluate(fact('foo' => 'Hello!'), []))
-    refute(t.evaluate(fact('bar' => ['Hello!']), []))
+    t = Factbase::Term.new(:eq, [:foo, 42])
+    assert(t.evaluate(fact('foo' => [42]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 'Hello!'), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => ['Hello!']), [], Factbase.new))
   end
 
   def test_zero
-    t = Factbase::Term.new(Factbase.new, :zero, [:foo])
-    assert(t.evaluate(fact('foo' => [0]), []))
-    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 0, 9, 'fdsf']), []))
-    refute(t.evaluate(fact('foo' => [100]), []))
-    refute(t.evaluate(fact('foo' => []), []))
-    refute(t.evaluate(fact('bar' => []), []))
+    t = Factbase::Term.new(:zero, [:foo])
+    assert(t.evaluate(fact('foo' => [0]), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 0, 9, 'fdsf']), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => []), [], Factbase.new))
   end
 
   def test_eq
-    t = Factbase::Term.new(Factbase.new, :eq, [:foo, 42])
-    assert(t.evaluate(fact('foo' => 42), []))
-    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 42, 9, 'fdsf']), []))
-    refute(t.evaluate(fact('foo' => [100]), []))
-    refute(t.evaluate(fact('foo' => []), []))
-    refute(t.evaluate(fact('bar' => []), []))
+    t = Factbase::Term.new(:eq, [:foo, 42])
+    assert(t.evaluate(fact('foo' => 42), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 42, 9, 'fdsf']), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => []), [], Factbase.new))
   end
 
   def test_eq_time
     now = Time.now
-    t = Factbase::Term.new(Factbase.new, :eq, [:foo, Time.parse(now.iso8601)])
-    assert(t.evaluate(fact('foo' => now), []))
-    assert(t.evaluate(fact('foo' => [now, Time.now]), []))
+    t = Factbase::Term.new(:eq, [:foo, Time.parse(now.iso8601)])
+    assert(t.evaluate(fact('foo' => now), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [now, Time.now]), [], Factbase.new))
   end
 
   def test_lt
-    t = Factbase::Term.new(Factbase.new, :lt, [:foo, 42])
-    assert(t.evaluate(fact('foo' => [10]), []))
-    refute(t.evaluate(fact('foo' => [100]), []))
-    refute(t.evaluate(fact('foo' => 100), []))
-    refute(t.evaluate(fact('bar' => 100), []))
+    t = Factbase::Term.new(:lt, [:foo, 42])
+    assert(t.evaluate(fact('foo' => [10]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 100), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => 100), [], Factbase.new))
   end
 
   def test_gte
-    t = Factbase::Term.new(Factbase.new, :gte, [:foo, 42])
-    assert(t.evaluate(fact('foo' => 100), []))
-    assert(t.evaluate(fact('foo' => 42), []))
-    refute(t.evaluate(fact('foo' => 41), []))
+    t = Factbase::Term.new(:gte, [:foo, 42])
+    assert(t.evaluate(fact('foo' => 100), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 42), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 41), [], Factbase.new))
   end
 
   def test_lte
-    t = Factbase::Term.new(Factbase.new, :lte, [:foo, 42])
-    assert(t.evaluate(fact('foo' => 41), []))
-    assert(t.evaluate(fact('foo' => 42), []))
-    refute(t.evaluate(fact('foo' => 100), []))
+    t = Factbase::Term.new(:lte, [:foo, 42])
+    assert(t.evaluate(fact('foo' => 41), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 42), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 100), [], Factbase.new))
   end
 
   def test_gt
-    t = Factbase::Term.new(Factbase.new, :gt, [:foo, 42])
-    assert(t.evaluate(fact('foo' => [100]), []))
-    assert(t.evaluate(fact('foo' => 100), []))
-    refute(t.evaluate(fact('foo' => [10]), []))
-    refute(t.evaluate(fact('foo' => 10), []))
-    refute(t.evaluate(fact('bar' => 10), []))
+    t = Factbase::Term.new(:gt, [:foo, 42])
+    assert(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 100), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [10]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 10), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => 10), [], Factbase.new))
   end
 
   def test_lt_time
-    t = Factbase::Term.new(Factbase.new, :lt, [:foo, Time.now])
-    assert(t.evaluate(fact('foo' => [Time.now - 100]), []))
-    refute(t.evaluate(fact('foo' => [Time.now + 100]), []))
-    refute(t.evaluate(fact('bar' => [100]), []))
+    t = Factbase::Term.new(:lt, [:foo, Time.now])
+    assert(t.evaluate(fact('foo' => [Time.now - 100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [Time.now + 100]), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => [100]), [], Factbase.new))
   end
 
   def test_gt_time
-    t = Factbase::Term.new(Factbase.new, :gt, [:foo, Time.now])
-    assert(t.evaluate(fact('foo' => [Time.now + 100]), []))
-    refute(t.evaluate(fact('foo' => [Time.now - 100]), []))
-    refute(t.evaluate(fact('bar' => [100]), []))
+    t = Factbase::Term.new(:gt, [:foo, Time.now])
+    assert(t.evaluate(fact('foo' => [Time.now + 100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [Time.now - 100]), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => [100]), [], Factbase.new))
   end
 
   def test_plus
-    t = Factbase::Term.new(Factbase.new, :plus, [:foo, 42])
-    assert_equal(46, t.evaluate(fact('foo' => 4), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:plus, [:foo, 42])
+    assert_equal(46, t.evaluate(fact('foo' => 4), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_plus_time
-    t = Factbase::Term.new(Factbase.new, :plus, [:foo, '12 days'])
-    assert_equal(Time.parse('2024-01-13'), t.evaluate(fact('foo' => Time.parse('2024-01-01')), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:plus, [:foo, '12 days'])
+    assert_equal(Time.parse('2024-01-13'), t.evaluate(fact('foo' => Time.parse('2024-01-01')), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_minus
-    t = Factbase::Term.new(Factbase.new, :minus, [:foo, 42])
-    assert_equal(58, t.evaluate(fact('foo' => 100), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:minus, [:foo, 42])
+    assert_equal(58, t.evaluate(fact('foo' => 100), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_minus_time
-    t = Factbase::Term.new(Factbase.new, :minus, [:foo, '4 hours'])
-    assert_equal(Time.parse('2024-01-01T06:04'), t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:minus, [:foo, '4 hours'])
+    assert_equal(Time.parse('2024-01-01T06:04'),
+                 t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_minus_time_singular
-    t = Factbase::Term.new(Factbase.new, :minus, [:foo, '1 hour'])
-    assert_equal(Time.parse('2024-01-01T09:04'), t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:minus, [:foo, '1 hour'])
+    assert_equal(Time.parse('2024-01-01T09:04'),
+                 t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 end

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)