casegen 2.0.0 → 3.0.0

data/test/agents/console_output_test.rb

@@ -1,27 +0,0 @@
-require_relative '../test_helper'
-require_relative '../../lib/agents/sets.rb'
-
-FakeAgent = Struct.new(:titles, :combinations)
-
-include CLabs::CaseGen
-
-class TestConsoleOutput < Minitest::Test
-  def test_simple_output
-    data = nil
-    agents = [
-      FakeAgent.new(["col a", "col b"], [[1, 2], [3, 4]])
-    ]
-    sio = StringIO.new
-    ConsoleOutput.new(data, agents, sio)
-    expected = <<~_
-      +-------+-------+
-      | col a | col b |
-      +-------+-------+
-      | 1     | 2     |
-      | 3     | 4     |
-      +-------+-------+
-
-    _
-    assert_equal expected, sio.string
-  end
-end

data/test/agents/sets.test.rb

@@ -1,227 +0,0 @@
-$LOAD_PATH << "#{__dir__}/../../lib/agents"
-require 'minitest/autorun'
-require 'sets'
-
-include CLabs::CaseGen
-
-class TestParsing < Minitest::Test
-  def test_sets_default
-    data = <<~CASEDATA
-      bar: 1, 2, 3,456.98
-       foo list:a, b, c
-    CASEDATA
-    cases = Sets.new(data)
-    assert_equal(2, cases.sets.length)
-    
-    assert_equal("bar", cases.sets[0].name)
-    assert_equal(["1", "2", "3,456.98"], cases.sets[0].data)
-    
-    assert_equal("foo list", cases.sets[1].name)
-    assert_equal(["a", "b", "c"], cases.sets[1].data)
-  end
-
-  def test_set_by_name_matching
-    # may seem obvious, but the regex matching used at one point would get confused when a name was reused in sets
-    sets = Sets.new("foo bar: 1, 2\nbar quux: 3, 4")
-    set = sets.set_by_name('bar quux')
-    assert_equal 'bar quux', set.name
-  end
-end
-
-class TestCombinations < Minitest::Test
-  def test_combos_2_by_2
-    sets = Sets.new("a: 1, 2\nb:3, 4")
-    assert_equal([['1', '3'], ['1', '4'], ['2', '3'], ['2', '4']], sets.combinations)
-    assert_equal(['a', 'b'], sets.titles)
-  end
-
-  def test_combos_2_by_3
-    sets = Sets.new("a: 1, 2\nb:3, 4, 5")
-    assert_equal([['1', '3'], ['1', '4'], ['1', '5'],
-                  ['2', '3'], ['2', '4'], ['2', '5']], sets.combinations)
-    assert_equal(['a', 'b'], sets.titles)
-  end
-end
-
-class TestRulesParsing < Minitest::Test
-  def test_rules_single
-    data = <<~RULES
-      exclude foo = bar
-    RULES
-    rules = Rules.new(data)
-    assert_equal(1, rules.length)
-    assert_equal(ExcludeRule, rules[0].class)
-    assert_equal("foo = bar", rules[0].criteria.to_s)
-    assert_equal("", rules[0].description)
-  end
-  
-  def test_rules_two
-    data = <<~RULES
-      exclude foo = bar
-        should foo equal bar, we want to exclude that combination
-      
-      exclude bar = foo
-        as well, if bar equals foo,
-        that case has got to go
-    RULES
-    rules = Rules.new(data)
-    assert_equal(2, rules.length)
-    assert_equal(ExcludeRule, rules[0].class)
-    assert_equal("foo = bar", rules[0].criteria.to_s)
-    assert_equal("should foo equal bar, we want to exclude that combination", rules[0].description)
-
-    assert_equal(ExcludeRule, rules[1].class)
-    assert_equal("bar = foo", rules[1].criteria.to_s)
-    assert_equal("as well, if bar equals foo,\nthat case has got to go", rules[1].description)
-  end
-  
-  def test_exclude_rule_parsing
-    data = <<~RULES
-      exclude foo = bar
-        should foo equal bar, we want to exclude that combination
-    RULES
-    rule = ExcludeRule.new(data)
-    assert_equal("foo = bar", rule.criteria.to_s)
-    assert_equal(["foo"], rule.criteria.set_names)
-    assert_equal(["bar"], rule.criteria.set_values)
-    assert_equal("should foo equal bar, we want to exclude that combination", rule.description)
-    
-  end
-  
-  def test_rules_set_name_not_found
-    sets = Sets.new("set.a: foo, bar\nset.b: fu, bahr")
-    data = <<~RULES
-      exclude set_a = bar AND set_b = barh
-        should foo equal bar, we want to exclude that combination
-    RULES
-    begin
-      Rules.new(data, [sets])
-      fail('should throw')
-    rescue ParserException => e
-      assert_equal("Invalid set name <set_a> in rule <set_a = bar AND set_b = barh>. Valid set names are <set.a, set.b>.", e.message)
-    end
-  end
-
-  def test_rules_set_value_not_found
-    sets = Sets.new("set a: foo, bar\nset b: fu, bahr")
-    data = <<~RULES
-      exclude set a = bar AND set b = barh
-        should foo equal bar, we want to exclude that combination
-    RULES
-    begin
-      Rules.new(data, [sets])
-      fail('should throw')
-    rescue ParserException => e
-      assert_equal("Invalid set value <barh> in rule <set a = bar AND set b = barh>. Valid set values for <set b> are <fu, bahr>.", e.message)
-    end
-  end
-  
-  class TestCriteria < Minitest::Test
-    def test_simple_equality
-      crit = Criteria.new("a = b")
-      assert_equal(['a'], crit.set_names)
-      assert_equal(['b'], crit.set_values)
-      assert_equal(true, crit.match({'a' => 'b'}))
-      assert_equal(false, crit.match({'a' => 'c'}))
-      assert_equal(false, crit.match({'b' => 'a'}))
-      assert_equal(true, crit.match({'a' => 'b', 'f' => 'g'}))
-    end
-    
-    def test_boolean_and
-      crit = Criteria.new("a = b AND c == d")
-      assert_equal(['a', 'c'], crit.set_names)
-      assert_equal(['b', 'd'], crit.set_values)
-      assert_equal(true, crit.match({'a' => 'b', 'c' => 'd'}))
-      assert_equal(false, crit.match({'a' => 'd', 'c' => 'b'}))
-      assert_equal(true, crit.match({'c' => 'd', 'a' => 'b'}))
-      assert_equal(false, crit.match({'a' => 'b'}))
-      assert_equal(false, crit.match({'c' => 'd'}))
-      assert_equal(false, crit.match({'a' => 'b', 'd' => 'c'}))
-      assert_equal(false, crit.match({'c' => 'd', 'b' => 'a'}))
-      
-      # not case sensitive
-      assert_equal(false, crit.match({'A' => 'b', 'c' => 'd'}))
-      assert_equal(false, crit.match({'a' => 'B', 'c' => 'd'}))
-      assert_equal(false, crit.match({'a' => 'b', 'C' => 'd'}))
-      assert_equal(false, crit.match({'a' => 'b', 'c' => 'D'}))
-    end
-    
-    def test_invalid_boolean_and
-      begin
-        Criteria.new("a = b AND a = d")
-        fail("should throw")
-      rescue ParserException => e
-        assert_equal("Rule cannot have the same set <a> equal to different values <b, d>", e.message)
-      end
-
-      begin
-        Criteria.new("a = b AND a = d AND a = c")
-        fail("should throw")
-      rescue ParserException => e
-        # in this case, the exception is figured out before the a = c can be parsed
-        assert_equal("Rule cannot have the same set <a> equal to different values <b, d>", e.message)
-      end
-    end
-  end
-  
-  class TestRulesOnSets < Minitest::Test
-    def test_simple
-      sets = Sets.new("a: 1, 2\nb: 3, 4")
-      rules = Rules.new("exclude a = 1\nexclude b=4", [sets])
-      assert_equal([['2', '3']], rules.combinations)
-      assert_equal(['a', 'b'], rules.titles)
-    end
-  end
-
-  class TestRubyCaseArray < Minitest::Test
-    def test_default_case_name
-      sets = Sets.new("a: 1, 2\nb:3, 4")
-      out = MockStdOut.new
-      RubyArrayOutput.new("", [sets], out)
-      expected = <<~TEXT
-        Case = Struct.new(:a, :b)
-
-        cases = [Case.new("1", "3"),
-                 Case.new("1", "4"),
-                 Case.new("2", "3"),
-                 Case.new("2", "4")]
-      TEXT
-      assert_equal(expected, out.to_s)
-    end
-
-    def test_specified_case_name
-      sets = Sets.new("a: 1, 2\nb:3, 4")
-      out = MockStdOut.new
-      RubyArrayOutput.new("DataSubmitCase", [sets], out)
-      expected = <<~TEXT
-        DataSubmitCase = Struct.new(:a, :b)
-
-        cases = [DataSubmitCase.new("1", "3"),
-                 DataSubmitCase.new("1", "4"),
-                 DataSubmitCase.new("2", "3"),
-                 DataSubmitCase.new("2", "4")]
-      TEXT
-      assert_equal(expected, out.to_s)
-    end
-  end
-
-  class MockStdOut
-    def initialize
-      @s = ''
-    end
-
-    def puts(s)
-      @s << s << "\n"
-    end
-
-    def print(s)
-      @s << s
-    end
-
-    def to_s
-      @s
-    end
-  end
-end
-
-

data/test/agents_test.rb

@@ -1,41 +0,0 @@
-$LOAD_PATH << "#{__dir__}/../lib"
-require 'minitest/autorun'
-require 'casegen'
-
-include CLabs::CaseGen
-
-class TestAgents < Minitest::Test
-  def setup
-    Agents.instance.clear
-  end
-
-  def teardown
-    Agents.instance.clear
-  end
-
-  def test_register
-    assert_equal(0, Agents.instance.length)
-    begin
-      Agents.instance.register("phil")
-      fail("should have thrown")
-    rescue AgentException
-      # expected -- can't register a non subclass
-    end
-
-    Agents.instance.register(SampleAgent)
-    assert_equal(1, Agents.instance.length)
-    Agents.instance.each do |ag| assert_equal(SampleAgent, ag) end
-  end
-
-  def test_get_agent_by_id
-    Agents.instance.register(SampleAgent)
-    result = Agents.instance.get_agent_by_id("sample")
-    assert_equal(SampleAgent, result)
-  end
-
-  def test_id_registered
-    assert_equal(false, Agents.instance.id_registered?(SampleAgent.agent_id))
-    Agents.instance.register(SampleAgent)
-    assert_equal(true, Agents.instance.id_registered?(SampleAgent.agent_id))
-  end
-end

data/test/parser_test.rb

@@ -1,163 +0,0 @@
-$LOAD_PATH << "#{__dir__}/../lib"
-require 'minitest/autorun'
-require 'casegen'
-
-include CLabs::CaseGen
-
-class SampleAgent < Agent
-  def SampleAgent.agent_id
-    "sample"
-  end
-end
-
-class Foo < Agent
-  def Foo.agent_id
-    "foo"
-  end
-end
-
-class TestParser < Minitest::Test
-  def setup
-    Agents.instance.register(SampleAgent)
-    Agents.instance.register(Foo)
-  end
-
-  def test_parse
-    data = <<~CASEDATA
-      sample
-      ------
-      sample_data
-      
-      foo
-      ---
-      sample_data
-      
-      sample(foo, sample)
-      ------------
-      sample_data
-      plus
-        some extra
-    CASEDATA
-
-    parser = Parser.new(data)
-    assert_equal(3, parser.agents.length)
-
-    sample_a = parser.agents[0]
-    foo = parser.agents[1]
-    sample_b = parser.agents[2]
-    assert_equal(SampleAgent, sample_a.class)
-    assert_equal("sample_data", sample_a.data)
-    assert_equal([], sample_a.reference_agents)
-
-    assert_equal(Foo, foo.class)
-    assert_equal("sample_data", foo.data)
-    assert_equal([], foo.reference_agents)
-
-    assert_equal(SampleAgent, sample_b.class)
-    assert_equal("sample_data\nplus\n  some extra", sample_b.data)
-    assert_equal([foo, sample_a], sample_b.reference_agents)
-  end
-
-  def test_parse_no_sets
-    data = <<~CASEDATA
-    CASEDATA
-
-    parser = Parser.new(data)
-    assert_equal(0, parser.agents.length)
-  end
-
-  def test_parse_agent_with_missing_hyphen_line
-    data = <<~CASEDATA
-      sample
-      
-      sample_data
-    CASEDATA
-
-    Parser.new(data)
-    fail("should have thrown")
-  rescue ParserException => e
-    assert_equal("Expected hyphen line after the agent declaration for <SampleAgent>", e.message)
-  end
-
-  def test_parse_agent_name_without_dash_delimiter
-    data = <<~CASEDATA
-      sample
-    CASEDATA
-
-    Parser.new(data)
-    fail("should have thrown")
-  rescue ParserException => e
-    assert_equal("Expected hyphen line after the agent declaration for <SampleAgent>", e.message)
-  end
-
-  def test_parse_agent_name_without_dash_delimiter_and_empty_line_to_start
-    data = <<~CASEDATA
-
-      sample
-    CASEDATA
-
-    Parser.new(data)
-    fail("should have thrown")
-  rescue ParserException => e
-    assert_equal("Expected hyphen line after the agent declaration for <SampleAgent>", e.message)
-  end
-
-  def test_parse_just_agent_with_underline
-    data = <<~CASEDATA
-      sample
-      -
-    CASEDATA
-
-    parser = Parser.new(data)
-    assert_equal(1, parser.agents.length)
-    sample = parser.agents[0]
-    assert_equal(SampleAgent, sample.class)
-    assert_equal("", sample.data)
-    assert_equal([], sample.reference_agents)
-  end
-
-  def test_parse_just_agent_with_empty_data
-    data = <<~CASEDATA
-      sample
-      -
-
-    CASEDATA
-
-    parser = Parser.new(data)
-    assert_equal(1, parser.agents.length)
-    sample = parser.agents[0]
-    assert_equal(SampleAgent, sample.class)
-    assert_equal("", sample.data)
-    assert_equal([], sample.reference_agents)
-  end
-
-  def test_parse_invalid_agent
-    data = <<~CASEDATA
-      sermple
-      ------
-      sample_data
-    CASEDATA
-
-    begin
-      Parser.new(data)
-      fail("should throw")
-    rescue ParserException
-      # expected
-    end
-  end
-
-  def test_parse_invalid_referenced_agent
-    data = <<~CASEDATA
-      sample(fu)
-      ------
-      sample_data
-    CASEDATA
-
-    begin
-      Parser.new(data)
-      fail("should throw")
-    rescue ParserException
-      # expected
-    end
-  end
-end