151 lines
6.5 KiB
Python
151 lines
6.5 KiB
Python
import pytest
|
|
|
|
from base import BaseTest
|
|
from conftest import NewOntology
|
|
from evaluators.base_evaluator import MultipleChoices
|
|
from helpers import _mt, _ut, get_concepts, get_from, get_metadata, get_parser_input
|
|
from parsers.SimpleConceptsParser import SimpleConceptsParser
|
|
|
|
|
|
class TestSimpleConceptsParser(BaseTest):
|
|
|
|
@pytest.fixture()
|
|
def parser(self):
|
|
return SimpleConceptsParser()
|
|
|
|
@pytest.mark.parametrize("text, expected", [
|
|
("I am a new concept", [_mt("1003", 0, 8)]),
|
|
("xxx yyy I am a new concept", [_ut("xxx yyy ", 0, 3), _mt("1003", 4, 12)]),
|
|
("I am a new concept xxx yyy", [_mt("1003", 0, 8), _ut(" xxx yyy", 9, 12)]),
|
|
("xxx I am a new concept yyy", [_ut("xxx ", 0, 1), _mt("1003", 2, 10), _ut(" yyy", 11, 12)]),
|
|
("c:#1003:", [_mt("1003", 0, 0)]),
|
|
("xxx c:#1003: yyy", [_ut("xxx ", 0, 1), _mt("1003", 2, 2), _ut(" yyy", 3, 4)]),
|
|
("xxx c:I am: yyy", [_ut("xxx ", 0, 1), _mt("1002", 2, 2), _ut(" yyy", 3, 4)]),
|
|
(" I am a new concept", [_ut(" ", 0, 0), _mt("1003", 1, 9)])
|
|
])
|
|
def test_i_can_recognize_a_concept(self, context, parser, text, expected):
|
|
with NewOntology(context, "test_i_can_recognize_a_concept"):
|
|
get_concepts(context, "I", "I am", "I am a new concept", use_sheerka=True)
|
|
|
|
pi = get_parser_input(text)
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
assert res == MultipleChoices([expected])
|
|
assert not error_sink
|
|
|
|
@pytest.mark.parametrize("text, expected", [
|
|
("foo", [_mt("1001", 0, 0)]),
|
|
("I am a new concept", [_mt("1001", 0, 8)])
|
|
])
|
|
def test_i_can_recognize_a_concept_by_its_name_and_its_definition(self, context, parser, text, expected):
|
|
with NewOntology(context, "test_i_can_recognize_a_concept_by_its_name_and_its_definition"):
|
|
get_concepts(context, get_metadata(name="foo", definition="I am a new concept"), use_sheerka=True)
|
|
|
|
pi = get_parser_input(text)
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
assert res == MultipleChoices([expected])
|
|
assert not error_sink
|
|
|
|
@pytest.mark.parametrize("text, expected", [
|
|
("long concept name", [_mt("1001", 0, 4)]),
|
|
("I am a new concept", [_mt("1001", 0, 8)])
|
|
])
|
|
def test_i_can_recognize_a_concept_by_its_name_when_long_name(self, context, parser, text, expected):
|
|
with NewOntology(context, "test_i_can_recognize_a_concept_by_its_name_when_long_name"):
|
|
get_concepts(context, get_metadata(name="long concept name", definition="I am a new concept"),
|
|
use_sheerka=True)
|
|
|
|
pi = get_parser_input(text)
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
assert res == MultipleChoices([expected])
|
|
assert not error_sink
|
|
|
|
def test_i_can_parse_a_sequence_of_concept(self, context, parser):
|
|
with NewOntology(context, "test_i_can_parse_a_sequence_of_concept"):
|
|
get_concepts(context, "foo bar", "baz", "qux", use_sheerka=True)
|
|
|
|
pi = get_parser_input("foo bar baz foo, qux")
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
expected = [_mt("1001", 0, 2),
|
|
_ut(" ", 3, 3),
|
|
_mt("1002", 4, 4),
|
|
_ut(" foo, ", 5, 8),
|
|
_mt("1003", 9, 9)]
|
|
|
|
assert res == MultipleChoices([expected])
|
|
assert not error_sink
|
|
|
|
def test_i_can_detect_multiple_choices(self, context, parser):
|
|
with NewOntology(context, "test_i_can_detect_multiple_choices"):
|
|
get_concepts(context, "foo bar", "bar baz", use_sheerka=True)
|
|
|
|
pi = get_parser_input("foo bar baz")
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
expected1 = [_mt("1001", 0, 2), _ut(" baz", 3, 4)]
|
|
expected2 = [_ut("foo ", 0, 1), _mt("1002", 2, 4)]
|
|
|
|
assert res == MultipleChoices([expected1, expected2])
|
|
assert not error_sink
|
|
|
|
def test_i_can_detect_multiple_choices_2(self, context, parser):
|
|
with NewOntology(context, "test_i_can_detect_multiple_choices_2"):
|
|
get_concepts(context, "one two", "one", "two", use_sheerka=True)
|
|
|
|
pi = get_parser_input("one two")
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
expected1 = [_mt("1001", 0, 2)]
|
|
expected2 = [_mt("1002", 0, 0), _ut(" ", 1, 1), _mt("1003", 2, 2)]
|
|
|
|
assert res == MultipleChoices([expected1, expected2])
|
|
assert not error_sink
|
|
|
|
def test_i_can_detect_multiple_choices_3(self, context, parser):
|
|
with NewOntology(context, "test_i_can_detect_multiple_choices_2"):
|
|
get_concepts(context, "one two", "one", "two", use_sheerka=True)
|
|
|
|
pi = get_parser_input("one two xxx one two")
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
e1 = get_from(_mt("c:one two#1001:"), _ut(" xxx "), _mt("c:#1001:"))
|
|
e2 = get_from(_mt("c:one#1002:"), _ut(" "), _mt("c:two#1003:"), _ut(" xxx "), _mt("c:one two#1001:"))
|
|
e3 = get_from(_mt("c:one two#1001:"), _ut(" xxx "), _mt("c:one#1002:"), _ut(" "), _mt("c:two#1003:"))
|
|
e4 = get_from(_mt("c:one#1002:"), _ut(" "), _mt("c:two#1003:"), _ut(" xxx "), _mt("c:#1002:"), _ut(" "),
|
|
_mt("c:#1003:"))
|
|
|
|
assert res == MultipleChoices([e1, e2, e3, e4])
|
|
assert not error_sink
|
|
|
|
def test_nothing_is_return_is_no_concept_is_recognized(self, context, parser):
|
|
pi = get_parser_input("one two three")
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
|
|
assert res == MultipleChoices([])
|
|
|
|
def test_i_can_manage_attribute_reference(self, context, parser):
|
|
with NewOntology(context, "test_i_can_detect_multiple_choices_2"):
|
|
get_concepts(context, "foo", "i am a concept", use_sheerka=True)
|
|
|
|
pi = get_parser_input("foo.attribute")
|
|
error_sink = []
|
|
res = parser.parse(context, pi, error_sink)
|
|
expected = [_mt("1001", 0, 0), _ut(".attribute", 1, 2)]
|
|
assert res == MultipleChoices([expected])
|
|
|
|
pi = get_parser_input("i am a concept.attribute")
|
|
res = parser.parse(context, pi, error_sink)
|
|
expected = [_mt("1002", 0, 6), _ut(".attribute", 7, 8)]
|
|
assert res == MultipleChoices([expected])
|