# import pytest
#
# from core.builtin_concepts import ReturnValueConcept, ParserResultConcept
# from core.concept import Concept
# from core.sheerka import Sheerka, ExecutionContext
# from evaluators.BaseEvaluator import BaseEvaluator
# from evaluators.ConceptComposerEvaluator import ConceptComposerEvaluator
# from parsers.BaseParser import BaseParser
# from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, Sequence
# from sdp.sheerkaDataProvider import Event
#
# concept_lexer_name = ConceptLexerParser().name
#
#
# def get_context():
#     sheerka = Sheerka(skip_builtins_in_db=True)
#     sheerka.initialize("mem://")
#     return ExecutionContext("test", Event(), sheerka)
#
#
# def get_return_values(context, grammar, expression):
#     parser = ConceptLexerParser()
#     parser.initialize(context, grammar)
#
#     ret_val = parser.parse(context, expression)
#     assert not ret_val.status
#     return [ret_val]
#
#
# def init(concepts, grammar, expression):
#     context = get_context()
#     for c in concepts:
#         context.sheerka.add_in_cache(c)
#     return_values = get_return_values(context, grammar, expression)
#
#     return context, return_values
#
#
# @pytest.mark.parametrize("return_values, expected", [
#     ([
#          ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
#          ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
#          ReturnValueConcept("not a parser", True, "some value"),
#      ], True),
#     ([
#          ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
#      ], True),
#     ([
#          ReturnValueConcept(BaseParser.PREFIX + "some_name", True, "not in error"),
#          ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
#      ], False),
#     ([
#          ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
#          ReturnValueConcept(concept_lexer_name, True, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
#      ], False),
#     ([
#          ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
#          ReturnValueConcept(concept_lexer_name, False, "some value"),
#      ], False),
#     ([
#          ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
#          ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=["not a concept"])),
#      ], False),
#     ([
#          ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", False, "evaluator in error"),
#          ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
#          ReturnValueConcept("not a parser", True, "some value"),
#      ], False),
#     ([
#          ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, "evaluator"),
#          ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
#          ReturnValueConcept("not a parser", True, "some value"),
#      ], False),
# ])
# def test_i_can_match(return_values, expected):
#     context = get_context()
#     assert ConceptComposerEvaluator().matches(context, return_values) == expected
#
#
# def test_i_can_eval_simple_concepts():
#     foo = Concept("foo", body="'foo'")
#     bar = Concept("bar", body="'bar'")
#     grammar = {}
#     context, return_values = init([foo, bar], grammar, "bar foo")
#
#     composer = ConceptComposerEvaluator()
#     assert composer.matches(context, return_values)
#
#     ret_val = composer.eval(context, return_values)
#     assert ret_val.status
#     assert ret_val.who == composer.name
#     assert ret_val.value == [Concept("bar", body="bar").init_key(), Concept("foo", body="foo").init_key()]
#     assert ret_val.value[0].metadata.is_evaluated
#     assert ret_val.value[1].metadata.is_evaluated
#     assert ret_val.parents == [return_values[0]]
#
#
# def test_i_can_eval_simple_concepts_when_some_are_bnf():
#     foo = Concept("foo", body="'foo'")
#     bar = Concept("bar", body="'bar'")
#     grammar = {foo: "foo"}
#     context, return_values = init([foo, bar], grammar, "bar foo")
#
#     composer = ConceptComposerEvaluator()
#     assert composer.matches(context, return_values)
#
#     ret_val = composer.eval(context, return_values)
#     assert ret_val.status
#     assert ret_val.who == composer.name
#     assert ret_val.value == [Concept("bar", body="bar").init_key(), Concept("foo", body="foo").init_key()]
#     assert ret_val.value[0].metadata.is_evaluated
#     assert ret_val.value[1].metadata.is_evaluated
#     assert ret_val.parents == [return_values[0]]
#
#
# def test_i_can_eval_simple_concept_and_text():
#     foo = Concept("foo", body="'foo'")
#     grammar = {}
#     context, return_values = init([foo], grammar, "'bar' foo")
#
#     composer = ConceptComposerEvaluator()
#     assert composer.matches(context, return_values)
#
#     ret_val = composer.eval(context, return_values)
#     assert ret_val.status
#     assert ret_val.who == composer.name
#     assert ret_val.value == "bar foo"
#     assert ret_val.parents == [return_values[0]]