factbase 0.15.0 → 0.15.1

data/test/factbase/test_syntax.rb

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require_relative '../../lib/factbase/syntax'
-
-# Syntax test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestSyntax < Factbase::Test
-  def test_parses_string_right
-    [
-      "(foo 'abc')",
-      "(foo 'one two')",
-      "(foo 'one two three   ')",
-      "(foo 'one two three   ' 'tail tail')"
-    ].each do |q|
-      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
-    end
-  end
-
-  def test_makes_abstract_terms
-    {
-      '(foo $bar)' => true,
-      '(foo (bar (a (b c (f $bar)))))' => true,
-      '(foo (bar (a (b c (f bar)))))' => false
-    }.each do |q, a|
-      assert_equal(a, Factbase::Syntax.new(q).to_term.abstract?)
-    end
-  end
-
-  def test_makes_static_terms
-    {
-      '(foo bar)' => false,
-      '(foo "bar")' => true,
-      '(agg (always) (max id))' => true
-    }.each do |q, a|
-      assert_equal(a, Factbase::Syntax.new(q).to_term.static?)
-    end
-  end
-
-  def test_simple_parsing
-    [
-      '(foo)',
-      '(foo (bar) (zz 77)   ) # hey',
-      "# hello\n\n\n(foo ($bar))",
-      "(eq foo   \n\n 'Hello, world!'\n)\n",
-      "(eq x 'Hello, \\' \n) \\' ( world!')",
-      "# this is a comment\n(eq foo # test\n 42)\n\n# another comment\n",
-      "(foo 'Hello,\n\nworld!\r\t\n')\n",
-      "(or ( a 4) (b 5) (always) (and (always) (c 5) \t\t(r 7 w8s w8is 'Foo')))"
-    ].each do |q|
-      refute_nil(Factbase::Syntax.new(q).to_term)
-    end
-  end
-
-  def test_exact_parsing
-    [
-      '(foo)',
-      '(foo 7)',
-      "(foo 7 'Dude')",
-      "(r 'Dude\\'s Friend')",
-      "(r 'I\\'m \\\"good\\\"')",
-      '(foo x y z)',
-      "(foo x y z t f 42 'Hi!# you' 33)",
-      '(foo (x) y z)',
-      '(eq t 2024-05-25T19:43:48Z)',
-      '(eq t 2024-05-25T19:43:48Z)',
-      '(eq t 3.1415926)',
-      '(eq t 3.0e+21)',
-      "(foo (x (f (t (y 42 'Hey you'))) (never) (r 3)) y z)"
-    ].each do |q|
-      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
-    end
-  end
-
-  def test_simple_matching
-    m = {
-      'foo' => ['Hello, world!'],
-      'bar' => [42],
-      'z' => [1, 2, 3, 4]
-    }
-    {
-      '(eq z 1)' => true,
-      '(or (eq bar 888) (eq z 1))' => true,
-      "(or (gt bar 100) (eq foo 'Hello, world!'))" => true
-    }.each do |k, v|
-      assert_equal(v, Factbase::Syntax.new(k).to_term.evaluate(m, [], Factbase.new), k)
-    end
-  end
-
-  def test_broken_syntax
-    [
-      '',
-      '()',
-      '(foo',
-      '(foo $)',
-      '(foo 1) (bar 2)',
-      'some text',
-      '"hello, world!',
-      '(foo 7',
-      "(foo 7 'Dude'",
-      '(foo x y z (',
-      '(bad-term-name 42)',
-      '(foo x y (z t (f 42 ',
-      ')foo ) y z)',
-      '(x "")',
-      ")y 42 'Hey you)",
-      ')',
-      '"'
-    ].each do |q|
-      msg = assert_raises(q) do
-        Factbase::Syntax.new(q).to_term
-      end.message
-      assert_includes(msg, q, msg)
-    end
-  end
-
-  def test_raises_on_broken_syntax
-    100.times do
-      q = [
-        '(', ')', '#test', '$foo', '%what',
-        '"hello"', '42', '+', '?', '!', '\"',
-        '\'', 'привет'
-      ].shuffle.join(' . ')
-      assert_raises(Factbase::Syntax::Broken, q) do
-        Factbase::Syntax.new(q).to_term
-      end
-    end
-  end
-
-  def test_simplification
-    {
-      '(foo)' => '(foo)',
-      '(and (foo) (foo))' => '(foo)',
-      '(and (foo) (or (and (eq a 1))) (eq a 1) (foo))' => '(and (foo) (eq a 1))'
-    }.each do |s, t|
-      assert_equal(t, Factbase::Syntax.new(s).to_term.to_s)
-    end
-  end
-
-  def test_fails_when_term_is_not_a_class
-    assert_raises(StandardError) { Factbase::Syntax.new('(foo 1)', term: 'hello') }
-  end
-
-  def test_fails_when_term_is_wrong_class
-    assert_raises(StandardError) { Factbase::Syntax.new('(bar 1)', term: String).to_term }
-  end
-
-  def test_fails_when_term_is_incorrectly_defined_class
-    assert_includes(
-      assert_raises(StandardError) { Factbase::Syntax.new('(bar 1)', term: FakeTerm).to_term }.message,
-      'wrong number of arguments'
-    )
-  end
-
-  class FakeTerm < Factbase::Term
-    def initialize(invalid)
-      super
-      @x = invalid
-    end
-  end
-end

data/test/factbase/test_tallied.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require 'threads'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/tallied'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestTallied < Factbase::Test
-  def test_counts_size
-    fb = Factbase::Tallied.new(Factbase.new)
-    assert_equal(0, fb.size)
-  end
-
-  def test_queries_empty_factbase
-    fb = Factbase::Tallied.new(Factbase.new)
-    assert_equal(0, fb.query('(gt foo 1)').each.to_a.size)
-  end
-
-  def test_counts_simple_changes
-    fb = Factbase::Tallied.new(Factbase.new)
-    fb.insert.bar = 3
-    fb.query('(exists bar)').each do |f|
-      f.foo = 42
-    end
-    assert_equal(1, fb.churn.inserted)
-    assert_equal(0, fb.churn.deleted)
-    assert_equal(2, fb.churn.added)
-  end
-
-  def test_counts_in_one
-    fb = Factbase::Tallied.new(Factbase.new)
-    fb.insert.bar = 3
-    assert_equal(1, fb.query('(agg (eq bar 3) (count))').one)
-    assert_equal(1, fb.churn.added)
-  end
-
-  def test_returns_all_props
-    fb = Factbase::Tallied.new(Factbase.new)
-    f = fb.insert
-    f.bar = 3
-    assert_includes(f.all_properties, 'bar')
-  end
-
-  def test_counts_in_txn
-    fb = Factbase::Tallied.new(Factbase.new)
-    fb.txn do |fbt|
-      fbt.insert.boom = 3
-      fbt.query('(exists boom)').each do |f|
-        f.foo = 88
-      end
-    end
-    assert_equal(1, fb.churn.inserted)
-    assert_equal(0, fb.churn.deleted)
-    assert_equal(2, fb.churn.added)
-  end
-
-  def test_counts_in_txn_in_threads
-    fb = Factbase::Tallied.new(Factbase.new)
-    t = 5
-    Threads.new(t).assert do |i|
-      fb.txn do |fbt|
-        fbt.insert.x = i
-        fbt.query("(eq x #{i})").each do |f|
-          f.send(:"a#{i}=", i)
-        end
-        fbt.query("(lt x #{t + 1})").delete!
-      end
-    end
-    assert_equal(0, fb.size)
-    assert_equal(t, fb.churn.inserted)
-    assert_equal(t, fb.churn.deleted)
-    assert_equal(t * 2, fb.churn.added)
-  end
-end

data/test/factbase/test_taped.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/taped'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestTaped < Factbase::Test
-  def test_tracks_insertion
-    t = Factbase::Taped.new([])
-    t << {}
-    assert_equal(1, t.inserted.size)
-  end
-
-  def test_joins_with_empty
-    t = Factbase::Taped.new([{ foo: 'yes' }])
-    t &= []
-    assert_equal(0, t.size)
-  end
-
-  def test_disjoins_with_empty
-    t = Factbase::Taped.new([{ bar: 'oops' }])
-    t |= []
-    assert_equal(1, t.size)
-  end
-
-  def test_tracks_deletion
-    t = Factbase::Taped.new([{ x: 1 }, { x: 2 }])
-    t.delete_if { |m| m[:x] == 1 }
-    assert_equal(1, t.deleted.size)
-  end
-
-  def test_tracks_addition
-    h = { f: 5 }
-    t = Factbase::Taped.new([h])
-    t.each do |m|
-      m[:bar] = 66
-    end
-    assert_equal(1, t.added.size)
-    assert_equal(h.object_id, t.added.first)
-  end
-
-  def test_tracks_addition_uniquely
-    h = { f: 5 }
-    t = Factbase::Taped.new([h])
-    t.each do |m|
-      m[:bar] = 66
-      m[:foo] = 77
-    end
-    assert_equal(1, t.added.size)
-  end
-
-  def test_tracks_factbase
-    t = Factbase::Taped.new([])
-    fb = Factbase.new(t)
-    fb.insert
-    fb.query('(always)').each do |f|
-      f.foo = 42
-      f.foo = 5
-    end
-    fb.query('(always)').delete!
-    assert_equal(1, t.inserted.size)
-    assert_equal(1, t.added.size)
-    assert_equal(1, t.deleted.size)
-  end
-end

data/test/factbase/test_tee.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/accum'
-require_relative '../../lib/factbase/tee'
-require_relative '../../lib/factbase/fact'
-
-def global_function_for_test_only(foo)
-  raise foo
-end
-
-# Tee test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestTee < Factbase::Test
-  def test_two_facts
-    prim = Factbase::Fact.new({})
-    prim.foo = 42
-    upper = Factbase::Fact.new({})
-    upper.bar = 13
-    t = Factbase::Tee.new(prim, upper)
-    assert_equal(42, t.foo)
-    assert_equal([13], t['$bar'])
-  end
-
-  def test_no_trip_to_prim_if_not_found
-    prim = Factbase::Fact.new({})
-    prim.foo = 777
-    t = Factbase::Tee.new(prim, Factbase::Fact.new({}))
-    assert_nil(t['$foo'])
-  end
-
-  def test_fetches_simply
-    t = Factbase::Accum.new(
-      Factbase::Tee.new(
-        Factbase::Fact.new({ 'foo_bar' => [987] }),
-        Factbase::Fact.new({})
-      ),
-      {}, true
-    )
-    assert_equal(987, t.foo_bar)
-  end
-
-  def test_fetches_without_conflict_with_global_name
-    t = Factbase::Tee.new(
-      Factbase::Fact.new({ 'global_function_for_test_only' => [2] }),
-      Factbase::Fact.new({})
-    )
-    assert_equal(2, t.global_function_for_test_only)
-  end
-
-  def test_all_properties
-    prim = Factbase::Fact.new({})
-    prim.foo = 42
-    upper = Factbase::Fact.new({})
-    upper.bar = 13
-    t = Factbase::Tee.new(prim, upper)
-    assert_includes(t.all_properties, 'foo')
-    assert_includes(t.all_properties, 'bar')
-  end
-
-  def test_recursively
-    map = {}
-    prim = Factbase::Fact.new(map)
-    prim.foo = 42
-    t = Factbase::Tee.new(Factbase::Fact.new({}), { 'bar' => [7] })
-    assert_equal([7], t['$bar'])
-    t = Factbase::Tee.new(prim, t)
-    assert_equal([7], t['$bar'])
-  end
-
-  def test_prints_to_string
-    prim = Factbase::Fact.new({})
-    prim.foo = 42
-    upper = Factbase::Fact.new({})
-    upper.bar = 13
-    t = Factbase::Tee.new(prim, upper)
-    assert_equal('[ foo: [42] ]', t.to_s)
-  end
-end

data/test/factbase/test_term.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/term'
-
-# Term test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestTerm < Factbase::Test
-  def test_false_matching
-    t = Factbase::Term.new(:never, [])
-    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
-  end
-
-  def test_size_matching
-    t = Factbase::Term.new(:size, [:foo])
-    assert_equal(3, t.evaluate(fact('foo' => [42, 12, -90]), [], Factbase.new))
-    assert_equal(0, t.evaluate(fact('bar' => 100), [], Factbase.new))
-  end
-
-  def test_exists_matching
-    t = Factbase::Term.new(:exists, [:foo])
-    assert(t.evaluate(fact('foo' => [42, 12, -90]), [], Factbase.new))
-    refute(t.evaluate(fact('bar' => 100), [], Factbase.new))
-  end
-
-  def test_absent_matching
-    t = Factbase::Term.new(:absent, [:foo])
-    assert(t.evaluate(fact('z' => [42, 12, -90]), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => 100), [], Factbase.new))
-  end
-
-  def test_type_matching
-    t = Factbase::Term.new(:type, [:foo])
-    assert_equal('Integer', t.evaluate(fact('foo' => 42), [], Factbase.new))
-    assert_equal('Integer', t.evaluate(fact('foo' => [42]), [], Factbase.new))
-    assert_equal('Array', t.evaluate(fact('foo' => [1, 2, 3]), [], Factbase.new))
-    assert_equal('String', t.evaluate(fact('foo' => 'Hello, world!'), [], Factbase.new))
-    assert_equal('Float', t.evaluate(fact('foo' => 3.14), [], Factbase.new))
-    assert_equal('Time', t.evaluate(fact('foo' => Time.now), [], Factbase.new))
-    assert_equal('Integer', t.evaluate(fact('foo' => 1_000_000_000_000_000), [], Factbase.new))
-    assert_equal('nil', t.evaluate(fact, [], Factbase.new))
-  end
-
-  def test_past
-    t = Factbase::Term.new(:prev, [:foo])
-    assert_nil(t.evaluate(fact('foo' => 4), [], Factbase.new))
-    assert_equal([4], t.evaluate(fact('foo' => 5), [], Factbase.new))
-  end
-
-  def test_at
-    t = Factbase::Term.new(:at, [1, :foo])
-    assert_nil(t.evaluate(fact('foo' => 4), [], Factbase.new))
-    assert_equal(5, t.evaluate(fact('foo' => [4, 5]), [], Factbase.new))
-  end
-
-  def test_report_missing_term
-    t = Factbase::Term.new(:something, [])
-    msg = assert_raises(StandardError) do
-      t.evaluate(fact, [], Factbase.new)
-    end.message
-    assert_includes(msg, 'not defined at (something)', msg)
-  end
-
-  def test_report_other_error
-    t = Factbase::Term.new(:at, [])
-    msg = assert_raises(StandardError) do
-      t.evaluate(fact, [], Factbase.new)
-    end.message
-    assert_includes(msg, 'at (at)', msg)
-  end
-
-  def test_redresses_itself
-    t = Factbase::Term.new(:something, [])
-    require_relative '../../lib/factbase/indexed/indexed_term'
-    t.redress!(Factbase::IndexedTerm)
-    require_relative '../../lib/factbase/cached/cached_term'
-    t.redress!(Factbase::CachedTerm)
-    assert_kind_of(Factbase::CachedTerm, t)
-    refute_kind_of(Factbase::CachedTerm, Factbase::Term.new(:something, []))
-  end
-end

data/test/factbase/test_to_json.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require 'loog'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/to_json'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestToJSON < Factbase::Test
-  def test_simple_rendering
-    fb = Factbase.new
-    f = fb.insert
-    f.foo = 42
-    f.foo = 256
-    to = Factbase::ToJSON.new(fb)
-    json = JSON.parse(to.json)
-    assert_equal(256, json[0]['foo'][1])
-  end
-
-  def test_sort_keys
-    fb = Factbase.new
-    f = fb.insert
-    f.c = 42
-    f.b = 1
-    f.a = 256
-    json = Factbase::ToJSON.new(fb).json
-    assert_includes(json, '{"a":256,"b":1,"c":42}', json)
-  end
-end

data/test/factbase/test_to_xml.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require 'loog'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/to_xml'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestToXML < Factbase::Test
-  def test_simple_rendering
-    fb = Factbase.new
-    fb.insert.t = Time.now
-    to = Factbase::ToXML.new(fb)
-    xml = Nokogiri::XML.parse(to.xml)
-    refute_empty(xml.xpath('/fb/f[t]'))
-    assert_match(
-      /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$/, xml.xpath('/fb/f/t/text()').text
-    )
-  end
-
-  def test_complex_rendering
-    fb = Factbase.new
-    fb.insert.t = "\uffff < > & ' \""
-    to = Factbase::ToXML.new(fb)
-    xml = Nokogiri::XML.parse(to.xml)
-    refute_empty(xml.xpath('/fb/f[t]'))
-  end
-
-  def test_meta_data_presence
-    fb = Factbase.new
-    fb.insert.x = 42
-    to = Factbase::ToXML.new(fb)
-    xml = Nokogiri::XML.parse(to.xml)
-    refute_empty(xml.xpath('/fb[@version]'))
-    refute_empty(xml.xpath('/fb[@size]'))
-  end
-
-  def test_to_xml_with_short_names
-    fb = Factbase.new
-    f = fb.insert
-    f.type = 1
-    f.f = 2
-    to = Factbase::ToXML.new(fb)
-    xml = Nokogiri::XML.parse(to.xml)
-    refute_empty(xml.xpath('/fb/f/type'))
-    refute_empty(xml.xpath('/fb/f/f'))
-  end
-
-  def test_show_types_as_attributes
-    fb = Factbase.new
-    f = fb.insert
-    f.a = 42
-    f.b = 3.14
-    f.c = 'Hello'
-    f.d = Time.now
-    f.e = 'e'
-    f.e = 4
-    out = Factbase::ToXML.new(fb).xml
-    xml = Nokogiri::XML.parse(out)
-    [
-      '/fb/f/a[@t="I"]',
-      '/fb/f/b[@t="F"]',
-      '/fb/f/c[@t="S"]',
-      '/fb/f/d[@t="T"]',
-      '/fb/f/e/v[@t="S"]',
-      '/fb/f/e/v[@t="I"]'
-    ].each { |x| refute_empty(xml.xpath(x), out) }
-  end
-
-  def test_sorts_keys
-    fb = Factbase.new
-    f = fb.insert
-    f.x = 20
-    f.t = 40
-    f.a = 10
-    f.c = 1
-    to = Factbase::ToXML.new(fb)
-    xml = Nokogiri::XML.parse(to.xml)
-    %w[a c t x].each_with_index do |e, i|
-      refute_empty(xml.xpath("/fb/f/#{e}[count(preceding-sibling::*) = #{i}]"), e)
-    end
-  end
-end

data/test/factbase/test_to_yaml.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require 'loog'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/to_yaml'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestToYAML < Factbase::Test
-  def test_simple_rendering
-    fb = Factbase.new
-    f = fb.insert
-    f._id = 1
-    f.foo = 42
-    f.foo = 256
-    fb.insert._id = 2
-    to = Factbase::ToYAML.new(fb)
-    yaml = YAML.load(to.yaml)
-    assert_equal(2, yaml.size)
-    assert_equal(42, yaml[0]['foo'][0])
-    assert_equal(256, yaml[0]['foo'][1])
-  end
-
-  def test_sorts_keys
-    fb = Factbase.new
-    f = fb.insert
-    f.b = 42
-    f.a = 256
-    f.c = 10
-    yaml = Factbase::ToYAML.new(fb).yaml
-    assert_includes(yaml, "a: 256\n  b: 42\n  c: 10", yaml)
-  end
-end

data/test/test__helper.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-$stdout.sync = true
-
-require 'simplecov'
-require 'simplecov-cobertura'
-unless SimpleCov.running || ENV['PICKS']
-  SimpleCov.command_name('test')
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-    [
-      SimpleCov::Formatter::HTMLFormatter,
-      SimpleCov::Formatter::CoberturaFormatter
-    ]
-  )
-  SimpleCov.minimum_coverage 95
-  SimpleCov.minimum_coverage_by_file 90
-  SimpleCov.start do
-    add_filter 'test/'
-    add_filter 'vendor/'
-    add_filter 'target/'
-    track_files 'lib/**/*.rb'
-    track_files '*.rb'
-  end
-end
-
-require 'minitest/autorun'
-require 'minitest/reporters'
-Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
-
-require_relative '../lib/factbase'
-
-# Default methods for all tests.
-class Factbase::Test < Minitest::Test
-  def fact(map = {})
-    require_relative '../lib/factbase/fact'
-    Factbase::Fact.new(map)
-  end
-end