282 lines
9.8 KiB
Python
282 lines
9.8 KiB
Python
import pytest
|
|
|
|
from common.global_symbols import NotInit
|
|
from core.concept import Concept, ConceptDefaultProps, ConceptMetadata, DefinitionType
|
|
from helpers import GetNextId, get_concept, get_concepts, get_evaluated_concept, get_from, get_metadata, \
|
|
get_metadatas
|
|
from tests.parsers.conftest import _mt, _ut
|
|
|
|
|
|
def test_i_can_get_default_value_when_get_metadata():
|
|
metadata = get_metadata()
|
|
assert metadata.id is None
|
|
assert metadata.name is None
|
|
assert metadata.name is None
|
|
assert metadata.body is None
|
|
assert metadata.id is None
|
|
assert metadata.key is None
|
|
assert metadata.where is None
|
|
assert metadata.pre is None
|
|
assert metadata.post is None
|
|
assert metadata.ret is None
|
|
assert metadata.definition is None
|
|
assert metadata.definition_type == DefinitionType.DEFAULT
|
|
assert metadata.desc is None
|
|
assert metadata.props == {}
|
|
assert metadata.variables == tuple()
|
|
assert metadata.parameters == []
|
|
assert metadata.bound_body is None
|
|
assert metadata.is_builtin is False
|
|
assert metadata.is_unique is False
|
|
assert metadata.autouse is False
|
|
|
|
|
|
def test_i_can_use_shortcut_to_declare_variables():
|
|
metadata = get_metadata(variables=(("var1", NotInit), ("var2", "value")))
|
|
assert metadata.variables == (("var1", NotInit), ("var2", "value")) # default behaviour
|
|
|
|
metadata = get_metadata(variables=[("var1", NotInit), ("var2", "value")])
|
|
assert metadata.variables == (("var1", NotInit), ("var2", "value")) # lists are transformed into tuples
|
|
|
|
metadata = get_metadata(variables=["var1", "var2"])
|
|
assert metadata.variables == (("var1", NotInit), ("var2", NotInit)) # expanded
|
|
|
|
|
|
def test_i_can_clone():
|
|
metadata = ConceptMetadata(
|
|
"id",
|
|
"name",
|
|
"key",
|
|
True,
|
|
True,
|
|
"body",
|
|
"where",
|
|
"pre",
|
|
"post",
|
|
"ret",
|
|
"definition",
|
|
DefinitionType.BNF,
|
|
"desc",
|
|
True,
|
|
"bound_body",
|
|
{"prop": "value"},
|
|
(("variable", "value"),),
|
|
("p1",),
|
|
"digest",
|
|
("all_attr",),
|
|
)
|
|
|
|
clone = metadata.clone()
|
|
for attr, value in vars(metadata).items():
|
|
clone_value = getattr(clone, attr)
|
|
assert clone_value == value
|
|
|
|
|
|
def test_i_can_override_values_when_i_clone_metadata():
|
|
metadata = get_metadata()
|
|
assert metadata.clone(name="new_name").name == "new_name"
|
|
assert metadata.clone(body="new_body").body == "new_body"
|
|
assert metadata.clone(key="new_key").key == "new_key"
|
|
assert metadata.clone(where="new_where").where == "new_where"
|
|
assert metadata.clone(pre="new_pre").pre == "new_pre"
|
|
assert metadata.clone(post="new_post").post == "new_post"
|
|
assert metadata.clone(ret="new_ret").ret == "new_ret"
|
|
assert metadata.clone(definition="new_definition").definition == "new_definition"
|
|
assert metadata.clone(definition_type="new_definition_type").definition_type == "new_definition_type"
|
|
assert metadata.clone(desc="new_desc").desc == "new_desc"
|
|
assert metadata.clone(props="new_props").props == "new_props"
|
|
assert metadata.clone(variables="new_variables").variables == "new_variables"
|
|
assert metadata.clone(parameters="new_parameters").parameters == "new_parameters"
|
|
assert metadata.clone(bound_body="new_bound_body").bound_body == "new_bound_body"
|
|
assert metadata.clone(is_builtin="new_is_builtin").is_builtin == "new_is_builtin"
|
|
assert metadata.clone(is_unique="new_is_unique").is_unique == "new_is_unique"
|
|
assert metadata.clone(autouse="new_autouse").autouse == "new_autouse"
|
|
assert metadata.clone(digest="new_digest").digest == "new_digest"
|
|
assert metadata.clone(all_attrs="new_all_attrs").all_attrs == "new_all_attrs"
|
|
|
|
|
|
def test_i_cannot_change_the_id_when_cloning():
|
|
with pytest.raises(TypeError):
|
|
metadata = get_metadata()
|
|
metadata.clone(id="new_id")
|
|
|
|
|
|
def test_i_can_auto_init():
|
|
next_id = GetNextId()
|
|
metadata = get_metadata("a plus b", body="a + b", variables=["a", "b"]).auto_init(next_id)
|
|
|
|
assert metadata.name == "a plus b"
|
|
assert metadata.id == "1001"
|
|
assert metadata.key == "__var__0 plus __var__1"
|
|
assert metadata.all_attrs == ('#where#', '#pre#', '#post#', '#body#', '#ret#', 'a', 'b')
|
|
assert metadata.is_unique is False
|
|
assert metadata.is_builtin is False
|
|
assert metadata.definition_type is DefinitionType.DEFAULT
|
|
assert metadata.digest == '9e058bc1261d1e2c785889147066ce89960fd6844db5bb6f1d1d809a8eb790b7'
|
|
|
|
|
|
def test_sequences_are_incremented_when_multiples_call():
|
|
next_id = GetNextId()
|
|
assert get_metadata("foo").auto_init(next_id).id == "1001"
|
|
assert get_metadata("bar").auto_init(next_id).id == "1002"
|
|
|
|
|
|
def test_i_can_get_multiple_metadatas():
|
|
res = get_metadatas("foo", get_metadata("bar", body="body"))
|
|
|
|
assert len(res) == 2
|
|
|
|
metadata = res[0]
|
|
assert isinstance(metadata, ConceptMetadata)
|
|
assert metadata.name == "foo"
|
|
assert metadata.body is None
|
|
assert metadata.key is None
|
|
assert metadata.id is None
|
|
|
|
metadata = res[1]
|
|
assert isinstance(metadata, ConceptMetadata)
|
|
assert metadata.name == "bar"
|
|
assert metadata.body == "body"
|
|
assert metadata.key is None
|
|
assert metadata.id is None
|
|
|
|
|
|
def test_i_can_get_multiple_already_initialized_metadatas():
|
|
res = get_metadatas("foo", get_metadata("bar", body="body"), next_id=GetNextId())
|
|
|
|
assert len(res) == 2
|
|
|
|
metadata = res[0]
|
|
assert isinstance(metadata, ConceptMetadata)
|
|
assert metadata.name == "foo"
|
|
assert metadata.body is None
|
|
assert metadata.key == "foo"
|
|
assert metadata.id == "1001"
|
|
|
|
metadata = res[1]
|
|
assert isinstance(metadata, ConceptMetadata)
|
|
assert metadata.name == "bar"
|
|
assert metadata.body == "body"
|
|
assert metadata.key == "bar"
|
|
assert metadata.id == "1002"
|
|
|
|
|
|
def test_i_can_get_a_concept():
|
|
foo = get_concept("foo", variables=("var1",))
|
|
|
|
assert isinstance(foo, Concept)
|
|
assert foo.name == "foo"
|
|
assert foo.key is None
|
|
assert foo.id is None
|
|
assert foo.all_attrs() == ('#where#', '#pre#', '#post#', '#body#', '#ret#', 'var1')
|
|
|
|
|
|
def test_i_can_request_basic_initialization_when_getting_a_concept():
|
|
next_id = GetNextId()
|
|
foo = get_concept("foo", variables=("var1",), sequence=next_id)
|
|
|
|
assert foo.name == "foo"
|
|
assert foo.key == "foo"
|
|
assert foo.id == "1001"
|
|
assert foo.all_attrs() == ('#where#', '#pre#', '#post#', '#body#', '#ret#', 'var1')
|
|
|
|
|
|
def test_i_can_get_multiple_concepts(context):
|
|
next_id = GetNextId()
|
|
|
|
foo, bar, baz = get_concepts(context,
|
|
"foo",
|
|
"bar",
|
|
get_concept("baz", definition="baz var1", variables=("var1",)),
|
|
sequence=next_id)
|
|
assert foo.name == "foo"
|
|
assert foo.id == "1001"
|
|
assert foo.key == "foo"
|
|
assert bar.name == "bar"
|
|
assert bar.id == "1002"
|
|
assert bar.key == "bar"
|
|
assert baz.name == "baz"
|
|
assert baz.id == "1003"
|
|
assert baz.key == "baz __var__0"
|
|
|
|
|
|
def test_i_can_get_multiple_concepts_using_sheerka(sheerka, context):
|
|
foo, bar, baz = get_concepts(context,
|
|
"foo",
|
|
"bar",
|
|
get_concept("baz", definition="baz var1", variables=("var1",)),
|
|
use_sheerka=True)
|
|
assert foo.name == "foo"
|
|
assert foo.id == "1001"
|
|
assert foo.key == "foo"
|
|
assert bar.name == "bar"
|
|
assert bar.id == "1002"
|
|
assert bar.key == "bar"
|
|
assert baz.name == "baz"
|
|
assert baz.id == "1003"
|
|
assert baz.key == "baz __var__0"
|
|
assert baz.get_value("var1") is NotInit
|
|
|
|
# the concepts are defined in Sheerka, so we can instantiate them
|
|
baz2 = sheerka.newn("baz", var1="value for var1")
|
|
assert baz2.name == "baz"
|
|
assert baz2.id == "1003"
|
|
assert baz2.key == "baz __var__0"
|
|
assert baz2.get_value("var1") == "value for var1"
|
|
|
|
|
|
def test_i_can_get_multiple_concepts_when_same_name(sheerka, context):
|
|
one_str, one_int = get_concepts(context,
|
|
get_metadata("one", body="'one'"),
|
|
get_metadata("one", body="1"),
|
|
use_sheerka=True)
|
|
|
|
assert sheerka.isinstance(one_str, "one")
|
|
assert sheerka.isinstance(one_int, "one")
|
|
|
|
|
|
def test_i_can_create_test_concept():
|
|
concept = get_concept("one", body="'one'")
|
|
|
|
test_concept = get_evaluated_concept(concept, body='hello', a="value for a")
|
|
|
|
assert test_concept.get_metadata() == concept.get_metadata()
|
|
assert test_concept.get_value(ConceptDefaultProps.BODY) == "hello"
|
|
assert test_concept.get_value("a") == "value for a"
|
|
|
|
|
|
def test_i_can_dummy_evaluate_concept():
|
|
concept = get_concept("one", body="'one'", where="True", pre="False", ret="1", post="1.0")
|
|
|
|
evaluated = get_evaluated_concept(concept)
|
|
assert evaluated.get_value(ConceptDefaultProps.WHERE) is True
|
|
assert evaluated.get_value(ConceptDefaultProps.PRE) is False
|
|
assert evaluated.get_value(ConceptDefaultProps.BODY) == "one"
|
|
assert evaluated.get_value(ConceptDefaultProps.RET) == 1
|
|
assert evaluated.get_value(ConceptDefaultProps.POST) == 1.0
|
|
|
|
concept = get_concept("one", body='"one"', ret="'a value'")
|
|
evaluated = get_evaluated_concept(concept, ret='forced value')
|
|
assert evaluated.get_value(ConceptDefaultProps.WHERE) == NotInit
|
|
assert evaluated.get_value(ConceptDefaultProps.PRE) == NotInit
|
|
assert evaluated.get_value(ConceptDefaultProps.BODY) == "one"
|
|
assert evaluated.get_value(ConceptDefaultProps.RET) == "forced value"
|
|
assert evaluated.get_value(ConceptDefaultProps.POST) == NotInit
|
|
|
|
|
|
def test_i_can_get_from():
|
|
res = get_from(_mt("c:i am a concept#1001:"))
|
|
assert res == [_mt("1001", 0, 6)]
|
|
|
|
res = get_from(_ut("some unrecognized stuff"))
|
|
assert res == [_ut("some unrecognized stuff", 0, 4)]
|
|
|
|
res = get_from(_mt("c:i am a concept#1001:"), _ut("some unrecognized stuff"))
|
|
assert res == [_mt("1001", 0, 6), _ut("some unrecognized stuff", 7, 11)]
|
|
|
|
res = get_from(_mt("c:i am a concept#1001:"), _ut("some unrecognized stuff"), parser="other")
|
|
assert res == [_mt("1001", 0, 6, parser="other"), _ut("some unrecognized stuff", 7, 11)]
|
|
|
|
res = get_from(_mt("c:i am a concept#1001:"), _mt("c:#1001:"))
|
|
assert res == [_mt("1001", 0, 6), _mt("1001", 7, 13)]
|