kodjo/Sheerka-Old
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored Caching, Refactored BnfNodeParser, Introduced Sphinx

Browse Source
This commit is contained in:
Kodjo Sossouvi
2020-05-12 17:21:10 +02:00
parent 7d3a490bc5
commit 6e343ba996
110 changed files with 13865 additions and 7540 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/core/test_SheerkaCreateNewConcept.py
+95 -150
View File
@@ -1,18 +1,20 @@
from core.builtin_concepts import BuiltinConcepts
from core.concept import PROPERTIES_TO_SERIALIZE, Concept, DEFINITION_TYPE_DEF
from core.sheerka.Sheerka import Sheerka
from sdp.sheerkaDataProvider import SheerkaDataProvider
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
def test_i_can_add_a_concept(self):
sheerka = self.get_sheerka()
def test_i_can_create_a_concept(self):
sheerka = self.get_sheerka(cache_only=False)
context = self.get_context(sheerka)
concept = self.get_default_concept()
res = sheerka.create_new_concept(self.get_context(sheerka), concept)
res = sheerka.create_new_concept(context, concept)
sheerka.cache_manager.commit(context)
assert res.status
assert sheerka.isinstance(res.value, BuiltinConcepts.NEW_CONCEPT)
@@ -24,22 +26,36 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
assert concept_found.key == "__var__0 + __var__1"
assert concept_found.id == "1001"
assert concept.key in sheerka.cache_by_key
assert concept.id in sheerka.cache_by_id
assert concept.name in sheerka.cache_by_name
assert sheerka.sdp.io.exists(
sheerka.sdp.io.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_found.get_origin()))
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_HASH_ENTRY, concept.get_definition_hash())
# saved in cache
assert sheerka.has_id(concept.id)
assert sheerka.has_key(concept.key)
assert sheerka.has_name(concept.name)
assert sheerka.has_hash(concept.get_definition_hash())
# I can get the concept using various index
assert sheerka.get_by_id(concept.id) == concept
assert sheerka.get_by_key(concept.key) == concept
assert sheerka.get_by_name(concept.name) == concept
assert sheerka.get_by_hash(concept.get_definition_hash()) == concept
# I can get by the first entry
assert sheerka.cache_manager.get(sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "+") == [concept.id]
assert sheerka.cache_manager.get(sheerka.RESOLVED_CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "+") == [concept.id]
# saved in sdp
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_ID_ENTRY, concept.id)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_KEY_ENTRY, concept.key)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_NAME_ENTRY, concept.name)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_ENTRY, concept.key)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_HASH_ENTRY, concept.get_definition_hash())
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "+")
def test_i_can_add_a_concept_when_name_differs_from_the_key(self):
sheerka = self.get_sheerka()
concept = Concept("greetings", definition="hello a", definition_type=DEFINITION_TYPE_DEF).def_prop("a")
sheerka = self.get_sheerka(cache_only=False)
context = self.get_context(sheerka)
concept = Concept("greetings", definition="hello a", definition_type=DEFINITION_TYPE_DEF).def_var("a")
res = sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka.cache_manager.commit(context)
assert res.status
assert sheerka.isinstance(res.value, BuiltinConcepts.NEW_CONCEPT)
@@ -51,15 +67,24 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
assert concept_found.key == "hello __var__0"
assert concept_found.id == "1001"
assert concept.key in sheerka.cache_by_key
assert concept.id in sheerka.cache_by_id
assert concept.name in sheerka.cache_by_name
assert sheerka.sdp.io.exists(
sheerka.sdp.io.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_found.get_origin()))
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_HASH_ENTRY, concept.get_definition_hash())
# saved in cache
assert sheerka.has_id(concept.id)
assert sheerka.has_key(concept.key)
assert sheerka.has_name(concept.name)
assert sheerka.has_hash(concept.get_definition_hash())
# I can get the concept using various index
assert sheerka.get_by_id(concept.id) == concept
assert sheerka.get_by_key(concept.key) == concept
assert sheerka.get_by_name(concept.name) == concept
assert sheerka.get_by_hash(concept.get_definition_hash()) == concept
# saved in sdp
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_ID_ENTRY, concept.id)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_KEY_ENTRY, concept.key)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_NAME_ENTRY, concept.name)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_ENTRY, concept.key)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_HASH_ENTRY, concept.get_definition_hash())
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "hello")
def test_i_cannot_add_the_same_concept_twice(self):
"""
@@ -82,7 +107,7 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
sheerka.create_new_concept(self.get_context(sheerka), concept)
from_cache = sheerka.get(concept.key)
from_cache = sheerka.get_by_key(concept.key)
assert from_cache is not None
assert from_cache == concept
@@ -90,57 +115,7 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
assert from_cache is not None
assert from_cache == concept
def test_i_first_look_in_local_cache(self):
sheerka = self.get_sheerka()
concept = self.get_default_concept()
sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka.cache_by_key[concept.key].pre = "I have modified the concept in cache"
from_cache = sheerka.get(concept.key)
assert from_cache is not None
assert from_cache.key == concept.key
assert from_cache.pre == "I have modified the concept in cache"
def test_i_can_get_a_known_concept_when_not_in_cache(self):
"""
When not in cache, uses sdp
:return:
"""
sheerka = self.get_sheerka()
concept = self.get_default_concept()
sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka.reset_cache()
loaded = sheerka.get(concept.key)
assert loaded == concept
# I can also get it by its id
loaded = sheerka.sdp.get(sheerka.CONCEPTS_BY_ID_ENTRY, concept.id)
assert loaded == concept
def test_i_can_instantiate_a_concept_from_sdp(self):
sheerka = self.get_sheerka()
concept = Concept("foo")
sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka.reset_cache()
loaded = sheerka.new("foo")
assert loaded == concept
def test_i_can_get_a_concept_by_its_id(self):
sheerka = self.get_sheerka()
concept = self.get_default_concept()
sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka.cache_by_key = {} # reset the cache
loaded = sheerka.get_by_id(concept.id)
assert loaded == concept
def test_i_can_get_list_of_concept_when_same_key_when_no_cache(self):
def test_i_can_get_list_of_concept_when_same_key_using_cache(self):
sheerka = self.get_sheerka()
concept1 = self.get_default_concept()
concept2 = self.get_default_concept()
@@ -149,79 +124,13 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
res1 = sheerka.create_new_concept(self.get_context(sheerka), concept1)
res2 = sheerka.create_new_concept(self.get_context(sheerka), concept2)
assert res1.status
assert res2.status
assert res1.value.body.key == res2.value.body.key # same key
sheerka.cache_by_key = {} # reset the cache
result = sheerka.get(concept1.key)
result = sheerka.get_by_key(concept1.key)
assert len(result) == 2
assert result[0] == concept1
assert result[1] == concept2
def test_i_can_get_list_of_concept_when_same_key_when_cache(self):
sheerka = self.get_sheerka()
concept1 = self.get_default_concept()
concept2 = self.get_default_concept()
concept2.metadata.body = "a+b"
res1 = sheerka.create_new_concept(self.get_context(sheerka), concept1)
res2 = sheerka.create_new_concept(self.get_context(sheerka), concept2)
assert res1.value.body.key == res2.value.body.key # same key
# sheerka.cache_by_key = {} # Do not reset the cache
result = sheerka.get(concept1.key)
assert len(result) == 2
assert result[0] == concept1
assert result[1] == concept2
def test_i_can_get_the_correct_concept_using_the_id_when_same_key_when_no_cache(self):
sheerka = self.get_sheerka()
concept1 = self.get_default_concept()
concept2 = self.get_default_concept()
concept2.metadata.body = "a+b"
res1 = sheerka.create_new_concept(self.get_context(sheerka), concept1)
res2 = sheerka.create_new_concept(self.get_context(sheerka), concept2)
assert res1.value.body.key == res2.value.body.key # same key
result = sheerka.get(concept1.key, res2.body.body.id)
assert result.name == "a + b"
assert result.metadata.body == "a+b"
def test_i_can_get_the_correct_concept_using_the_id__when_same_key_when_cache(self):
sheerka = self.get_sheerka()
concept1 = self.get_default_concept()
concept2 = self.get_default_concept()
concept2.metadata.body = "a+b"
res1 = sheerka.create_new_concept(self.get_context(sheerka), concept1)
res2 = sheerka.create_new_concept(self.get_context(sheerka), concept2)
assert res1.value.body.key == res2.value.body.key # same key
result = sheerka.get(concept1.key, res2.body.body.id)
assert result.name == "a + b"
assert result.metadata.body == "a+b"
def test_i_cannot_get_the_correct_concept_id_the_id_is_wrong(self):
sheerka = self.get_sheerka()
concept1 = self.get_default_concept()
concept2 = self.get_default_concept()
concept2.metadata.body = "a+b"
res1 = sheerka.create_new_concept(self.get_context(sheerka), concept1)
res2 = sheerka.create_new_concept(self.get_context(sheerka), concept2)
assert res1.value.body.key == res2.value.body.key # same key
result = sheerka.get(concept1.key, "wrong id")
assert sheerka.isinstance(result, BuiltinConcepts.UNKNOWN_CONCEPT)
def test_concept_that_references_itself_is_correctly_created(self):
sheerka = self.get_sheerka()
concept = Concept("foo", body="foo")
@@ -233,27 +142,63 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
class TestSheerkaCreateNewConceptFileBased(TestUsingFileBasedSheerka):
def test_i_can_add_several_concepts(self):
sheerka, context, hello, greeting = self.init_concepts(
Concept("Hello world a").def_prop("a"),
Concept("Greeting a").def_prop("a"),
use_dict=False
)
res = sheerka.create_new_concept(self.get_context(sheerka), hello)
sheerka = self.get_sheerka()
context = self.get_context(sheerka)
hello = Concept("Hello world a").def_var("a")
res = sheerka.create_new_concept(context, hello)
sheerka.cache_manager.commit(context)
assert res.status
sheerka = self.get_sheerka(use_dict=False)
res = sheerka.create_new_concept(self.get_context(sheerka), greeting)
sheerka = self.get_sheerka() # another instance
context = self.get_context(sheerka)
greeting = Concept("Greeting a").def_var("a")
res = sheerka.create_new_concept(context, greeting)
sheerka.cache_manager.commit(context)
assert res.status
assert sheerka.sdp.exists(Sheerka.CONCEPTS_ENTRY, hello.key)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_ENTRY, greeting.key)
sheerka = self.get_sheerka() # another instance again
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_KEY_ENTRY, hello.key)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_KEY_ENTRY, greeting.key)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_ID_ENTRY, hello.id)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_ID_ENTRY, greeting.id)
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_NAME_ENTRY, "Hello world a")
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_NAME_ENTRY, "Greeting a")
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_HASH_ENTRY, hello.get_definition_hash())
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_HASH_ENTRY, greeting.get_definition_hash())
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "Hello")
assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "Greeting")
def test_i_cannot_add_the_same_concept_twice_using_sdp(self):
"""
Checks that duplicated concepts are managed by sheerka, not by sheerka.sdp
:return:
"""
sheerka = self.get_sheerka(cache_only=False)
context = self.get_context(sheerka)
concept = self.get_default_concept()
sheerka.create_new_concept(context, concept)
sheerka.cache_manager.commit(context)
sheerka.cache_manager.clear()
res = sheerka.create_new_concept(context, concept)
assert not res.status
assert sheerka.isinstance(res.value, BuiltinConcepts.CONCEPT_ALREADY_DEFINED)
assert res.value.body == concept
def test_new_entry_does_not_override_the_previous_ones(self):
sheerka = self.get_sheerka()
context = self.get_context(sheerka)
sheerka.create_new_concept(context, Concept("foo", body="1"))
sheerka.create_new_concept(context, Concept("foo", body="2"))
sheerka.cache_manager.commit(context)
assert len(sheerka.sdp.get(Sheerka.CONCEPTS_BY_KEY_ENTRY, "foo")) == 2
sheerka = self.get_sheerka() # new instance
sheerka.create_new_concept(context, Concept("foo", body="3"))
sheerka.cache_manager.commit(context)
assert len(sheerka.sdp.get(Sheerka.CONCEPTS_BY_KEY_ENTRY, "foo")) == 3
tests/core/test_SheerkaEvaluateConcept.py
+161 -167
View File
@@ -1,6 +1,6 @@
import pytest
from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, ParserResultConcept
from core.concept import Concept, simplec, DoNotResolve, ConceptParts, Property, InfiniteRecursionResolved
from core.concept import Concept, DoNotResolve, ConceptParts, Property, InfiniteRecursionResolved, CB
from parsers.PythonParser import PythonNode
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
@@ -9,8 +9,8 @@ from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
@pytest.mark.parametrize("body, expected", [
# (None, None),
# ("", ""),
(None, None),
("", ""),
("1", 1),
("1+1", 2),
("'one'", "one"),
@@ -19,10 +19,9 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
("1 > 2", False),
])
def test_i_can_evaluate_a_concept_with_simple_body(self, body, expected):
sheerka = self.get_sheerka()
sheerka, context, concept = self.init_concepts(Concept("foo", body=body), eval_body=True)
concept = Concept("foo", body=body).init_key()
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == expected
@@ -30,7 +29,7 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
assert evaluated.metadata.pre is None
assert evaluated.metadata.post is None
assert evaluated.metadata.where is None
assert evaluated.props == {}
assert evaluated.variables() == {}
assert evaluated.metadata.is_evaluated
assert len(evaluated.values) == 0 if body is None else 1
@@ -51,18 +50,17 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
:return:
"""
sheerka = self.get_sheerka()
sheerka, context, concept = self.init_concepts(Concept("foo", pre=expr))
concept = Concept("foo", pre=expr).init_key()
evaluated = sheerka.evaluate_concept(self.get_context(sheerka), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.metadata.body is None
assert evaluated.metadata.pre == expr
assert evaluated.metadata.post is None
assert evaluated.metadata.where is None
assert evaluated.get_metadata_value(ConceptParts.PRE) == expected
assert evaluated.props == {}
assert evaluated.get_value(ConceptParts.PRE) == expected
assert evaluated.variables() == {}
assert not evaluated.metadata.is_evaluated
assert len(evaluated.values) == 0 if expr is None else 1
@@ -77,124 +75,121 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
("1 > 2", False),
])
def test_i_can_evaluate_a_concept_with_prop(self, expr, expected):
sheerka = self.get_sheerka()
sheerka, context, concept = self.init_concepts(Concept("foo").def_var("a", expr), eval_body=True)
concept = Concept("foo").def_prop("a", expr)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka,True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.metadata.pre is None
assert evaluated.metadata.pre is None
assert evaluated.metadata.post is None
assert evaluated.metadata.where is None
assert evaluated.props == {"a": Property("a", expected)}
assert evaluated.variables() == {"a": Property("a", expected)}
assert evaluated.metadata.is_evaluated
def test_i_can_evaluate_metadata_using_do_not_resolve(self):
sheerka = self.get_sheerka()
concept = Concept("foo")
sheerka, context, concept = self.init_concepts(Concept("foo"), eval_body=True)
concept.compiled[ConceptParts.BODY] = DoNotResolve("do not resolve")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.body == "do not resolve"
assert evaluated.metadata.is_evaluated
def test_i_can_evaluate_property_using_do_not_resolve(self):
sheerka = self.get_sheerka()
concept = Concept("foo").def_prop("a")
sheerka, context, concept = self.init_concepts(Concept("foo").def_var("a"), eval_body=True)
concept.compiled["a"] = DoNotResolve("do not resolve")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.get_prop("a") == "do not resolve"
assert evaluated.get_value("a") == "do not resolve"
assert evaluated.metadata.is_evaluated
def test_original_value_is_overridden_when_using_do_no_resolve(self):
sheerka = self.get_sheerka()
concept = Concept("foo", body="original value").set_prop("a", "original value")
concept = Concept("foo", body="original value").def_var("a", "original value")
sheerka, context, concept = self.init_concepts(concept, eval_body=True)
concept.compiled["a"] = DoNotResolve("do not resolve")
concept.compiled[ConceptParts.BODY] = DoNotResolve("do not resolve")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.body == "do not resolve"
assert evaluated.get_prop("a") == "do not resolve"
assert evaluated.get_value("a") == "do not resolve"
assert evaluated.metadata.is_evaluated
def test_props_are_evaluated_before_body(self):
sheerka = self.get_sheerka()
def test_variables_are_evaluated_before_body(self):
sheerka, context, concept = self.init_concepts(Concept("foo", body="a+1").def_var("a", "10"), eval_body=True)
concept = Concept("foo", body="a+1").def_prop("a", "10").init_key()
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == 11
assert evaluated == CB(concept, 11)
def test_i_can_evaluate_when_another_concept_is_referenced(self):
sheerka = self.get_sheerka()
concept_a = Concept("a")
sheerka.add_in_cache(concept_a)
sheerka, context, concept_a, concept = self.init_concepts(
Concept("a"),
Concept("foo", body="a"),
eval_body=True)
concept = Concept("foo", body="a").init_key()
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated == simplec("foo", simplec("a", None))
assert id(evaluated.body) != id(concept_a)
assert evaluated == CB("foo", CB("a", None))
assert evaluated.metadata.is_evaluated
assert evaluated.body.metadata.is_evaluated
def test_i_can_evaluate_when_the_referenced_concept_has_a_body(self):
sheerka = self.get_sheerka()
concept_a = Concept("a", body="1")
sheerka.add_in_cache(concept_a)
sheerka, context, concept_a, concept = self.init_concepts(
Concept("a", body="1"),
Concept("foo", body="a"),
eval_body=True)
concept = Concept("foo", body="a")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == simplec("a", 1)
assert evaluated.body == CB("a", 1)
assert not concept_a.metadata.is_evaluated
assert evaluated.metadata.is_evaluated
def test_i_can_evaluate_concept_of_concept_when_the_leaf_has_a_body(self):
sheerka = self.get_sheerka()
sheerka.add_in_cache(Concept(name="a", body="'a'"))
sheerka.add_in_cache(Concept(name="b", body="a"))
sheerka.add_in_cache(Concept(name="c", body="b"))
concept_d = sheerka.add_in_cache(Concept(name="d", body="c"))
sheerka, context, concept_a, concept_b, concept_c, concept_d = self.init_concepts(
Concept("a", body="'a'"),
Concept("b", body="a"),
Concept("c", body="b"),
Concept("d", body="c"),
eval_body=True)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept_d)
evaluated = sheerka.evaluate_concept(context, concept_d)
assert evaluated.key == concept_d.key
expected = simplec("c", simplec("b", simplec("a", "a")))
expected = CB("c", CB("b", CB("a", "a")))
assert evaluated.body == expected
assert sheerka.value(evaluated) == 'a'
assert sheerka.objvalue(evaluated) == 'a'
assert evaluated.metadata.is_evaluated
def test_i_can_evaluate_concept_of_concept_does_not_have_a_body(self):
sheerka = self.get_sheerka()
sheerka.add_in_cache(Concept(name="a"))
sheerka.add_in_cache(Concept(name="b", body="a"))
sheerka.add_in_cache(Concept(name="c", body="b"))
concept_d = sheerka.add_in_cache(Concept(name="d", body="c"))
sheerka, context, concept_a, concept_b, concept_c, concept_d = self.init_concepts(
Concept("a"),
Concept("b", body="a"),
Concept("c", body="b"),
Concept("d", body="c"),
eval_body=True)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept_d)
evaluated = sheerka.evaluate_concept(context, concept_d)
assert evaluated.key == concept_d.key
expected = simplec("c", simplec("b", simplec("a", None)))
expected = CB("c", CB("b", CB("a", None)))
assert evaluated.body == expected
assert sheerka.value(evaluated) == Concept(name="a").init_key()
assert sheerka.objvalue(evaluated) == CB("a", None)
assert evaluated.metadata.is_evaluated
def test_i_can_evaluate_concept_when_properties_reference_others_concepts(self):
sheerka = self.get_sheerka()
concept_a = sheerka.add_in_cache(Concept(name="a").init_key())
sheerka, context, concept_a, concept = self.init_concepts(
Concept("a"),
Concept("foo", body="a").def_var("a", "a"),
eval_body=True)
concept = Concept("foo", body="a").def_prop("a", "a").init_key()
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
# first prop a is evaluated to concept_a
# first, prop a is evaluated to concept_a
# then body is evaluated to prop a -> concept_a
assert evaluated.key == concept.key
assert evaluated.body == concept_a
@@ -205,49 +200,49 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
but the name of the property and the name of the concept are different
:return:
"""
sheerka = self.get_sheerka()
concept_a = sheerka.add_in_cache(Concept(name="a"))
sheerka, context, concept_a = self.init_concepts(Concept(name="a"), eval_body=True)
concept = Concept("foo", body="concept_a").def_prop("concept_a", "a")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
concept = Concept("foo", body="concept_a").def_var("concept_a", "a")
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == concept_a
def test_i_can_evaluate_concept_when_properties_reference_others_concepts_with_body(self):
sheerka = self.get_sheerka()
sheerka.add_in_cache(Concept(name="a", body="1"))
sheerka.add_in_cache(Concept(name="b", body="2"))
sheerka, context, *concepts = self.init_concepts(
Concept(name="a", body="1"),
Concept(name="b", body="2"),
eval_body=True
)
concept = Concept("foo", body="propA + propB").def_prop("propA", "a").def_prop("propB", "b")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
concept = Concept("foo", body="propA + propB").def_var("propA", "a").def_var("propB", "b")
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == 3
def test_i_can_evaluate_concept_when_properties_is_a_concept(self):
sheerka = self.get_sheerka()
concept_a = sheerka.add_in_cache(Concept(name="a", body="'a'").init_key())
sheerka, context, concept_a = self.init_concepts(Concept(name="a", body="'a'"), eval_body=True)
concept = Concept("foo").def_prop("a")
concept = Concept("foo").def_var("a")
concept.compiled["a"] = concept_a
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.get_prop("a") == simplec("a", "a")
assert evaluated.get_value("a") == CB("a", "a")
def test_i_can_evaluate_when_property_asts_is_a_list(self):
sheerka = self.get_sheerka()
foo = Concept("foo", body="1")
concept = Concept("to_eval").def_prop("prop")
concept = Concept("to_eval").def_var("prop")
concept.compiled["prop"] = [foo, DoNotResolve("1")]
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
props = evaluated.get_prop("prop")
assert len(props) == 2
assert props[0] == simplec("foo", 1)
assert props[1] == "1"
variables = evaluated.get_value("prop")
assert len(variables) == 2
assert variables[0] == CB("foo", 1)
assert variables[1] == "1"
def test_i_can_evaluate_when_compiled_is_set_up_with_return_value(self):
sheerka = self.get_sheerka()
@@ -255,16 +250,16 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
python_node = PythonNode("1 +1 ")
parser_result = ParserResultConcept(parser="who", value=python_node)
concept = Concept("to_eval").def_prop("prop")
concept = Concept("to_eval").def_var("prop")
concept.compiled["prop"] = [ReturnValueConcept("who", True, parser_result)]
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
assert evaluated.get_prop("prop") == 2
assert evaluated.get_value("prop") == 2
# also works when only one return value
concept = Concept("to_eval").def_prop("prop")
concept = Concept("to_eval").def_var("prop")
concept.compiled["prop"] = ReturnValueConcept("who", True, parser_result)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
assert evaluated.get_prop("prop") == 2
assert evaluated.get_value("prop") == 2
def test_i_can_reference_sheerka(self):
sheerka = self.get_sheerka()
@@ -276,49 +271,55 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
assert evaluated.body == sheerka.test()
def test_properties_values_takes_precedence_over_the_outside_world(self):
sheerka = self.get_sheerka()
sheerka.add_in_cache(Concept(name="a", body="'concept_a'"))
sheerka.add_in_cache(Concept(name="b", body="'concept_b'"))
sheerka, context, concept_a, concept_b = self.init_concepts(
Concept(name="a", body="'concept_a'"),
Concept(name="b", body="'concept_b'"),
eval_body=True
)
concept = Concept("foo", body="a")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == simplec("a", "concept_a") # this test was already done
assert evaluated.body == CB("a", "concept_a") # this test was already done
# so check this one.
concept = Concept("foo", body="a").def_prop("a", "'property_a'")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
concept = Concept("foo", body="a").def_var("a", "'property_a'")
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == 'property_a'
# or this one.
concept = Concept("foo", body="a").def_prop("a", "b")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
concept = Concept("foo", body="a").def_var("a", "b")
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == simplec(name="b", body="concept_b")
assert evaluated.body == CB("b", "concept_b")
def test_properties_values_takes_precedence(self):
sheerka = self.get_sheerka()
sheerka.add_in_cache(Concept(name="a", body="'concept_a'"))
sheerka.add_in_cache(Concept(name="b", body="'concept_b'"))
sheerka, context, concept_a, concept_b = self.init_concepts(
Concept(name="a", body="'concept_a'"),
Concept(name="b", body="'concept_b'"),
eval_body=True
)
concept = Concept("foo", body="a + b").def_prop("a", "'prop_a'").init_key()
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
concept = Concept("foo", body="a + b").def_var("a", "'prop_a'").init_key()
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == 'prop_aconcept_b'
def test_i_can_reference_sub_property_of_a_property(self):
sheerka = self.get_sheerka()
sheerka.add_in_cache(Concept(name="concept_a").def_prop("subProp", "'sub_a'"))
sheerka, context, concept_a = self.init_concepts(
Concept(name="concept_a").def_var("subProp", "'sub_a'"),
eval_body=True
)
concept = Concept("foo", body="a.props['subProp'].value").def_prop("a", "concept_a")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
assert evaluated == simplec(concept.key, "sub_a")
concept = Concept("foo", body="a.subProp").def_var("a", "concept_a")
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated == CB(concept.key, "sub_a")
def test_i_cannot_evaluate_concept_if_property_is_in_error(self):
sheerka = self.get_sheerka()
concept = Concept(name="concept_a").def_prop("subProp", "undef_concept")
concept = Concept(name="concept_a").def_var("subProp", "undef_concept")
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
assert sheerka.isinstance(evaluated, BuiltinConcepts.CONCEPT_EVAL_ERROR)
@@ -340,11 +341,10 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
("a + self > 20", True),
])
def test_i_can_evaluate_simple_where(self, where_clause, expected):
sheerka = self.get_sheerka()
concept = Concept("foo", body="10", where=where_clause).def_prop("a", "20")
sheerka.add_in_cache(concept)
sheerka, context, concept = self.init_concepts(
Concept("foo", body="10", where=where_clause).def_var("a", "20"),
)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, False, True), concept)
if expected:
@@ -354,12 +354,10 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
assert evaluated.body == concept
def test_i_can_evaluate_where_when_using_other_concept(self):
sheerka = self.get_sheerka()
foo_true = Concept("foo_true", body="True").init_key()
foo_false = Concept("foo_false", body="False").init_key()
sheerka.add_in_cache(foo_false)
sheerka.add_in_cache(foo_true)
sheerka, context, foo_true, foo_false = self.init_concepts(
Concept("foo_true", body="True"),
Concept("foo_false", body="False"),
)
concept = Concept("foo", where="foo_true").init_key()
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, False, True), concept)
@@ -375,12 +373,9 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
assert evaluated.key == concept.key
def test_i_can_evaluate_disable_where_clause_evaluation(self):
sheerka = self.get_sheerka()
concept = Concept("foo", body="10", where="a > 10").def_prop("a", None)
sheerka.add_in_cache(concept)
context = self.get_context(sheerka)
sheerka, context, concept = self.init_concepts(
Concept("foo", body="10", where="a > 10").def_var("a", None),
)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
@@ -389,82 +384,84 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
assert sheerka.isinstance(evaluated, BuiltinConcepts.CONCEPT_EVAL_ERROR)
def test_i_can_detect_infinite_recursion_with_numeric_constant(self):
sheerka = self.get_sheerka()
one_str = Concept("one", body="1")
one_digit = Concept("1", body="one")
sheerka, context, one_str, one_digit = self.init_concepts(
Concept("one", body="1"),
Concept("1", body="one"),
eval_body=True
)
sheerka.add_in_cache(one_str)
sheerka.add_in_cache(one_digit)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), one_digit)
evaluated = sheerka.evaluate_concept(context, one_digit)
assert evaluated.key == one_digit.key
assert evaluated.body == InfiniteRecursionResolved(1)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), one_str)
evaluated = sheerka.evaluate_concept(context, one_str)
assert evaluated.key == one_str.key
assert evaluated.body == InfiniteRecursionResolved(1)
def test_i_can_detect_infinite_recursion_with_boolean_constant(self):
sheerka = self.get_sheerka()
sheerka, context, true_str, true_bool = self.init_concepts(
Concept("true", body="True"),
Concept("True", body="true"),
eval_body=True
)
true_str = Concept("true", body="True")
true_bool = Concept("True", body="true")
sheerka.add_in_cache(true_str)
sheerka.add_in_cache(true_bool)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), true_str)
evaluated = sheerka.evaluate_concept(context, true_str)
assert evaluated.key == true_str.key
assert evaluated.body == InfiniteRecursionResolved(True)
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), true_bool)
evaluated = sheerka.evaluate_concept(context, true_bool)
assert evaluated.key == true_bool.key
assert evaluated.body == InfiniteRecursionResolved(True)
def test_i_can_detect_infinite_recursion_with_constant_with_more_concepts(self):
sheerka = self.get_sheerka()
c1 = sheerka.add_in_cache(Concept("one", body="1"))
c2 = sheerka.add_in_cache(Concept("1", body="2"))
c3 = sheerka.add_in_cache(Concept("2", body="3"))
c4 = sheerka.add_in_cache(Concept("3", body="one"))
sheerka, context, c1, c2, c3, c4 = self.init_concepts(
Concept("one", body="1"),
Concept("1", body="2"),
Concept("2", body="3"),
Concept("3", body="one"),
eval_body=True
)
for concept in (c1, c2, c3, c4):
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
evaluated = sheerka.evaluate_concept(context, concept)
assert evaluated.key == concept.key
assert evaluated.body == InfiniteRecursionResolved(3)
def test_i_can_detect_infinite_recursion_when_no_constant(self):
sheerka = self.get_sheerka()
sheerka, context, foo, bar, baz, qux = self.init_concepts(
Concept("foo", body="bar"),
Concept("bar", body="baz"),
Concept("baz", body="qux"),
Concept("qux", body="foo"),
eval_body=True
)
foo = sheerka.add_in_cache(Concept("foo", body="bar"))
bar = sheerka.add_in_cache(Concept("bar", body="baz"))
baz = sheerka.add_in_cache(Concept("baz", body="qux"))
qux = sheerka.add_in_cache(Concept("qux", body="foo"))
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), foo)
evaluated = sheerka.evaluate_concept(context, foo)
assert sheerka.isinstance(evaluated, BuiltinConcepts.CHICKEN_AND_EGG)
assert evaluated.body == {foo, bar, baz, qux}
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), bar)
evaluated = sheerka.evaluate_concept(context, bar)
assert sheerka.isinstance(evaluated, BuiltinConcepts.CHICKEN_AND_EGG)
assert evaluated.body == {foo, bar, baz, qux}
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), baz)
evaluated = sheerka.evaluate_concept(context, baz)
assert sheerka.isinstance(evaluated, BuiltinConcepts.CHICKEN_AND_EGG)
assert evaluated.body == {foo, bar, baz, qux}
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), qux)
evaluated = sheerka.evaluate_concept(context, qux)
assert sheerka.isinstance(evaluated, BuiltinConcepts.CHICKEN_AND_EGG)
assert evaluated.body == {foo, bar, baz, qux}
def test_i_can_detect_auto_recursion(self):
sheerka = self.get_sheerka()
sheerka, context, foo = self.init_concepts(
Concept("foo", body="foo"),
eval_body=True
)
foo = sheerka.add_in_cache(Concept("foo", body="foo"))
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), foo)
evaluated = sheerka.evaluate_concept(context, foo)
assert sheerka.isinstance(evaluated, BuiltinConcepts.CHICKEN_AND_EGG)
assert evaluated.body == {foo}
@@ -475,6 +472,3 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), one)
assert evaluated.key == one.key
assert evaluated.body == 1
tests/core/test_SheerkaHistoryManager.py
+2 -1
View File
@@ -4,7 +4,8 @@ from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
class TestSheerkaHistoryManager(TestUsingMemoryBasedSheerka):
def test_i_can_retrieve_history(self):
sheerka = self.get_sheerka(skip_builtins_in_db=False, singleton=False)
sheerka = self.get_sheerka(singleton=False)
sheerka.save_execution_context = True
sheerka.evaluate_user_input("def concept one as 1")
sheerka.evaluate_user_input("one")
tests/core/test_SheerkaModifyConcept.py
+63 -68
View File
@@ -1,96 +1,79 @@
import pytest
from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept, ConceptParts
from core.sheerka.Sheerka import Sheerka
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
class TestSheerkaModifyConcept(TestUsingMemoryBasedSheerka):
def test_i_can_modify_a_concept(self):
sheerka, context, foo, bar = self.init_concepts("foo", "bar", create_new=True)
sheerka, context, foo, bar = self.init_concepts("foo", "bar", create_new=True, cache_only=False)
foo_instance = sheerka.new("foo")
foo_instance.metadata.body = "value" # modify metadata
foo_instance.set_prop(BuiltinConcepts.ISA, bar) # modify property
foo_instance.set_metadata_value(ConceptParts.BODY, "body value") # modify value
foo_instance.metadata.body = "metadata value" # modify metadata
foo_instance.def_var("var_name", "default value") # modify definition of variables
foo_instance.add_prop(BuiltinConcepts.ISA, bar) # modify property
foo_instance.set_value(ConceptParts.BODY, "body value") # modify value
foo_instance.set_value("var_name", "var value") # modify value
res = sheerka.modify_concept(context, foo_instance)
assert res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.NEW_CONCEPT)
assert res.body.body.metadata.body == "value"
assert res.body.body.get_prop(BuiltinConcepts.ISA) == bar
assert res.body.body.metadata.body == "metadata value"
assert res.body.body.metadata.variables == [("var_name", "default value")]
assert res.body.body.get_prop(BuiltinConcepts.ISA) == {bar}
assert res.body.body.body == "body value"
assert res.body.body.get_value("var_name") == "var value"
# test that object
sheerka.reset_cache()
foo_from_sheerka = sheerka.new("foo")
assert foo_from_sheerka.metadata.body == "value"
assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == bar
foo_from_sheerka = sheerka.get_by_key("foo")
assert foo_from_sheerka.metadata.body == "metadata value"
assert foo_from_sheerka.metadata.variables == [("var_name", "default value")]
assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == {bar}
assert foo_from_sheerka.body == "body value"
assert foo_from_sheerka.get_value("var_name") == "var value"
# test that ref by id is updated
sheerka.reset_cache()
foo_from_sheerka = sheerka.get_by_id(foo.id)
assert foo_from_sheerka.metadata.body == "value"
assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == bar
assert foo_from_sheerka.body == "body value"
# other caches are also updated
assert sheerka.get_by_id(foo.id).metadata.body == "metadata value"
assert sheerka.get_by_name(foo.name).metadata.body == "metadata value"
assert sheerka.get_by_hash(foo_instance.get_definition_hash()).metadata.body == "metadata value"
# test that ref by name is updated
sheerka.reset_cache()
foo_from_sheerka = sheerka.get_by_name(foo.name)
assert foo_from_sheerka.metadata.body == "value"
assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == bar
assert foo_from_sheerka.body == "body value"
# test that ref by hash is updated
foo_from_sdp = sheerka.sdp.get(Sheerka.CONCEPTS_BY_HASH_ENTRY, foo_instance.get_definition_hash())
assert foo_from_sdp.metadata.body == "value"
assert foo_from_sdp.get_prop(BuiltinConcepts.ISA) == bar
assert foo_from_sdp.body == "body value"
# previous ref by hash is removed (since that definition hash has changed)
with pytest.raises(IndexError):
sheerka.sdp.get(Sheerka.CONCEPTS_BY_HASH_ENTRY, foo_instance.get_original_definition_hash())
def test_i_can_modify_concept_modifying_only_properties_and_body(self):
sheerka, context, foo, bar = self.init_concepts("foo", "bar", create_new=True)
foo_instance = sheerka.new("foo")
foo_instance.set_prop(BuiltinConcepts.ISA, bar)
foo_instance.set_metadata_value(ConceptParts.BODY, "body value")
res = sheerka.modify_concept(context, foo_instance)
assert res.status
foo_from_sheerka = sheerka.new("foo")
assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == bar
assert foo_from_sheerka.body == "body value"
def test_cache_is_updated_when_a_concept_is_modified(self):
sheerka, context, foo = self.init_concepts("foo", create_new=True)
foo_instance = sheerka.new("foo")
foo_instance.metadata.body = "value"
res = sheerka.modify_concept(context, foo_instance)
assert res.status
foo_from_sheerka = sheerka.get("foo")
assert foo_from_sheerka.metadata.body == "value"
foo_by_id_from_sheerka = sheerka.get_by_id(foo.id)
assert foo_by_id_from_sheerka.metadata.body == "value"
# sdp can be updated
sheerka.cache_manager.commit(context)
from_sdp = sheerka.sdp.get(sheerka.CONCEPTS_BY_ID_ENTRY, foo.id)
assert from_sdp.metadata.body == "metadata value"
assert from_sdp.metadata.variables == [("var_name", "default value")]
assert from_sdp.get_prop(BuiltinConcepts.ISA) == {bar}
assert from_sdp.body == "body value"
assert from_sdp.get_value("var_name") == "var value"
def test_i_cannot_modify_a_concept_that_does_not_exists(self):
sheerka, context, foo = self.init_concepts("foo", create_new=False)
sheerka, context = self.init_concepts()
foo_instance = sheerka.new("foo")
foo_instance.metadata.body = "value"
res = sheerka.modify_concept(context, foo_instance)
foo = Concept("foo").init_key()
sheerka.set_id_if_needed(foo, False)
res = sheerka.modify_concept(context, foo)
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.UNKNOWN_CONCEPT)
assert res.body.body.key == foo.key
assert res.body.body == ("id", foo.id)
def test_i_cannot_modify_a_concept_that_returns_an_error(self):
sheerka, context = self.init_concepts()
foo = Concept("foo").init_key()
res = sheerka.modify_concept(context, foo)
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
def test_i_cannot_modify_if_the_concept_has_not_changed(self):
sheerka, context, foo = self.init_concepts("foo", create_new=True)
res = sheerka.modify_concept(context, foo)
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.CONCEPT_ALREADY_DEFINED)
def test_i_can_modify_a_concept_that_is_in_a_list(self):
sheerka, context, foo1, foo2 = self.init_concepts(
@@ -105,7 +88,19 @@ class TestSheerkaModifyConcept(TestUsingMemoryBasedSheerka):
assert sheerka.isinstance(res.body, BuiltinConcepts.NEW_CONCEPT)
assert res.body.body.metadata.body == "value"
sheerka.reset_cache()
foo_from_sheerka = sheerka.new("foo")
assert foo_from_sheerka[0].metadata.body == "1"
assert foo_from_sheerka[1].metadata.body == "value"
class TestSheerkaModifyConceptUsingFile(TestUsingFileBasedSheerka):
def test_i_can_modify_a_concept_from_a_new_sheerka(self):
sheerka, context, foo = self.init_concepts("foo", create_new=True)
sheerka.cache_manager.commit(context)
sheerka = self.get_sheerka()
foo.add_prop("a", "b")
res = sheerka.modify_concept(context, foo)
assert res.status
tests/core/test_SheerkaSetsManager.py
+175 -101
View File
@@ -1,79 +1,65 @@
from core.builtin_concepts import ConceptAlreadyInSet, BuiltinConcepts
from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
class TestSheerkaSetsManager(TestUsingMemoryBasedSheerka):
# def init(self, use_dict, *concepts):
# sheerka = self.get_sheerka(use_dict, True)
# for c in concepts:
# sheerka.set_id_if_needed(c, False)
# sheerka.add_in_cache(c)
#
# context = self.get_context(sheerka)
# return sheerka, context
def test_i_can_add_a_concept_to_a_set(self):
sheerka, context, foo, group = self.init_concepts(
Concept("foo"),
Concept("group"),
cache_only=False
)
assert sheerka.add_concept_to_set(context, foo, group).status
def test_i_can_add_concept_to_set(self):
sheerka, context, foo, all_foos = self.init_concepts(Concept("foo"), Concept("all_foo"), use_dict=False)
group_elements = sheerka.cache_manager.get(sheerka.CONCEPTS_GROUPS_ENTRY, group.id)
assert group_elements == {foo.id}
res = sheerka.add_concept_to_set(context, foo, all_foos)
assert res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
all_entries = self.get_sheerka(use_dict=False).sdp.get("All_" + all_foos.id, None, False)
assert len(all_entries) == 1
assert foo.id in all_entries
def test_i_can_add_several_concepts_to_set(self):
sheerka, context, foo1, foo2, all_foos = self.init_concepts(
Concept("foo1"),
Concept("foo2"),
Concept("all_foo"), use_dict=False)
res = sheerka.sets_handler.add_concepts_to_set(context, (foo1, foo2), all_foos)
assert res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
all_entries = self.get_sheerka(use_dict=False).sdp.get("All_" + all_foos.id, None, False)
assert len(all_entries) == 2
assert foo1.id in all_entries
assert foo2.id in all_entries
# I can add another elements
foo3 = Concept("foo3")
foo4 = Concept("foo4")
for c in [foo3, foo4]:
sheerka.set_id_if_needed(c, False)
sheerka.add_in_cache(c)
res = sheerka.sets_handler.add_concepts_to_set(context, (foo3, foo4), all_foos)
assert res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
all_entries = self.get_sheerka(use_dict=False).sdp.get("All_" + all_foos.id, None, False)
assert len(all_entries) == 4
assert foo1.id in all_entries
assert foo2.id in all_entries
assert foo3.id in all_entries
assert foo4.id in all_entries
# it can be persisted
sheerka.cache_manager.commit(context)
assert sheerka.sdp.get(sheerka.CONCEPTS_GROUPS_ENTRY, group.id) == {foo.id}
def test_i_cannot_add_the_same_concept_twice_in_a_set(self):
sheerka, context, foo, all_foos = self.init_concepts(Concept("foo"), Concept("all_foos"))
sheerka, context, foo, group = self.init_concepts(Concept("foo"), Concept("group"))
sheerka.add_concept_to_set(context, foo, group)
sheerka.add_concept_to_set(context, foo, all_foos)
res = sheerka.add_concept_to_set(context, foo, all_foos)
# add again
res = sheerka.add_concept_to_set(context, foo, group)
assert not res.status
assert res.body == ConceptAlreadyInSet(foo, all_foos)
assert sheerka.isinstance(res.body, BuiltinConcepts.CONCEPT_ALREADY_IN_SET)
assert res.body.body == foo
assert res.body.concept_set == group
all_entries = sheerka.sdp.get("All_" + all_foos.id, None, False)
assert len(all_entries) == 1
assert foo.id in all_entries
all_entries = sheerka.cache_manager.get(sheerka.CONCEPTS_GROUPS_ENTRY, group.id)
assert all_entries == {foo.id}
def test_i_can_have_multiple_groups(self):
sheerka, context, foo, bar, baz, group1, group2 = self.init_concepts(
Concept("foo"),
Concept("bar"),
Concept("baz"),
Concept("group1"),
Concept("group2"),
cache_only=False
)
assert sheerka.add_concept_to_set(context, foo, group1).status
assert sheerka.add_concept_to_set(context, bar, group1).status
assert sheerka.add_concept_to_set(context, bar, group2).status
assert sheerka.add_concept_to_set(context, baz, group2).status
assert sheerka.cache_manager.get(sheerka.CONCEPTS_GROUPS_ENTRY, group1.id) == {foo.id, bar.id}
assert sheerka.cache_manager.get(sheerka.CONCEPTS_GROUPS_ENTRY, group2.id) == {baz.id, bar.id}
# I can save in db
sheerka.cache_manager.commit(context)
assert sheerka.sdp.get(sheerka.CONCEPTS_GROUPS_ENTRY) == {
'1004': {'1001', '1002'}, '1005': {'1002', '1003'}
}
def test_i_get_elements_from_a_set(self):
sheerka, context, one, two, three, number = self.init_concepts(
@@ -83,7 +69,6 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
sheerka.add_concept_to_set(context, c, number)
elements = sheerka.get_set_elements(context, number)
assert set(elements) == {one, two, three}
def test_i_cannot_get_elements_if_not_a_set(self):
@@ -100,8 +85,9 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
assert not sheerka.isaset(context, group)
assert not sheerka.isinset(foo, group)
context = self.get_context(sheerka)
context = self.get_context(sheerka) # another context ?
sheerka.add_concept_to_set(context, foo, group)
assert sheerka.isaset(context, group)
assert sheerka.isinset(foo, group)
@@ -112,7 +98,7 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
sheerka.sets_handler.add_concepts_to_set(context, [foo, bar], group1)
assert sheerka.isaset(context, group2)
assert sheerka.get_set_elements(context, group2) == [foo, bar]
assert set(sheerka.get_set_elements(context, group2)) == {foo, bar}
def test_i_can_define_subset_of_another_group(self):
sheerka, context, one, two, three, four, five, number, sub_number = self.init_concepts(
@@ -122,15 +108,30 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
Concept("four", body="4"),
Concept("five", body="5"),
Concept("number"),
Concept("sub_number", body="number", where="number < 4"),
create_new=True
Concept("sub_number", body="number", where="number < 4")
)
sheerka.sets_handler.add_concepts_to_set(context, [one, two, three, four, five], number)
assert sheerka.isaset(context, sub_number)
assert sheerka.get_set_elements(context, sub_number) == [one, two, three]
assert set(sheerka.get_set_elements(context, sub_number)) == {one, two, three}
def test_i_can_define_subset_of_another_set_when_some_concept_dont_have_a_defined_body(self):
def test_i_can_define_subset_of_subset(self):
sheerka, context, one, two, three, four, five, number, sub_number, sub_sub_number = self.init_concepts(
Concept("one", body="1"),
Concept("two", body="2"),
Concept("three", body="3"),
Concept("four", body="4"),
Concept("five", body="5"),
Concept("number"),
Concept("sub_number", body="number", where="number < 4"),
Concept("sub_sub_number", body="sub_number", where="sub_number > 2")
)
sheerka.sets_handler.add_concepts_to_set(context, [one, two, three, four, five], number)
assert sheerka.isaset(context, sub_sub_number)
assert set(sheerka.get_set_elements(context, sub_sub_number)) == {three}
def test_i_can_define_subset_of_another_set_when_some_concept_do_not_have_a_defined_body(self):
"""
Example
def concept unit from number where number <10
@@ -151,7 +152,7 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
sheerka.sets_handler.add_concepts_to_set(context, [one, two, three, four, five], number)
assert sheerka.isaset(context, sub_number)
assert sheerka.get_set_elements(context, sub_number) == [one, three]
assert set(sheerka.get_set_elements(context, sub_number)) == {one, three}
def test_i_can_define_subset_of_another_set_when_some_concept_are_bnf(self):
"""
@@ -190,8 +191,9 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
Concept("one", body="1"),
Concept("two", body="2"),
Concept("twenty", body="20"),
Concept("twenties", definition="twenty (one|two)=unit", body="twenty + unit").def_prop("unit"),
Concept("twenties", definition="twenty (one|two)=unit", body="twenty + unit").def_var("unit"),
Concept("number"),
create_new=True
)
sheerka.sets_handler.add_concepts_to_set(context, [one, two, twenty, twenties], number)
@@ -200,39 +202,27 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
twenty_one = sheerka.evaluate_user_input("twenty one", "")[0].body
assert sheerka.isinset(twenty_one, number)
def test_i_can_set_isa(self):
sheerka, context, foo, all_foos = self.init_concepts(
"foo", "all_foo",
create_new=True,
use_dict=False)
assert BuiltinConcepts.ISA not in foo.props
sheerka.set_isa(context, foo, all_foos)
assert foo.get_prop(BuiltinConcepts.ISA) == [all_foos]
assert sheerka.isa(foo, all_foos)
assert sheerka.isinset(foo, all_foos)
assert sheerka.isaset(context, all_foos)
def test_a_concept_can_be_in_multiple_sets(self):
sheerka, context, foo, all_foos, all_bars = self.init_concepts(
sheerka, context, foo, all_foo, all_bar = self.init_concepts(
Concept("foo"),
Concept("all_foo"),
Concept("all_bar"),
use_dict=False)
sheerka.create_new_concept(context, foo)
create_new=True
)
sheerka.set_isa(context, foo, all_foos)
sheerka.set_isa(context, foo, all_bars)
foo = sheerka.new(foo.key) # new instance
sheerka.set_isa(context, foo, all_foo)
assert foo.get_prop(BuiltinConcepts.ISA) == [all_foos, all_bars]
assert sheerka.isa(foo, all_foos)
assert sheerka.isa(foo, all_bars)
assert sheerka.isinset(foo, all_foos)
assert sheerka.isinset(foo, all_bars)
assert sheerka.isaset(context, all_foos)
assert sheerka.isaset(context, all_bars)
foo = sheerka.new(foo.key) # new instance
sheerka.set_isa(context, foo, all_bar)
assert foo.get_prop(BuiltinConcepts.ISA) == {all_foo, all_bar}
assert sheerka.isa(foo, all_foo)
assert sheerka.isa(foo, all_bar)
assert sheerka.isinset(foo, all_foo)
assert sheerka.isinset(foo, all_bar)
assert sheerka.isaset(context, all_foo)
assert sheerka.isaset(context, all_bar)
def test_i_can_manage_isa_transitivity(self):
"""
@@ -244,10 +234,9 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
Concept("foo"),
Concept("bar"),
Concept("baz"),
create_new=True
)
sheerka.create_new_concept(context, foo)
sheerka.create_new_concept(context, bar)
sheerka.create_new_concept(context, baz)
sheerka.set_isa(context, foo, bar)
sheerka.set_isa(context, bar, baz)
@@ -255,3 +244,88 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
assert sheerka.isa(foo, bar)
assert sheerka.isa(bar, baz)
assert sheerka.isa(foo, baz)
class TestSheerkaSetsManagerUsingFileBasedSheerka(TestUsingFileBasedSheerka):
def test_i_can_add_concept_to_set_and_retrieve_it_in_another_session(self):
sheerka, context, foo, bar, group = self.init_concepts(
Concept("foo"),
Concept("bar"),
Concept("group"),
create_new=True)
assert sheerka.add_concept_to_set(context, foo, group).status
sheerka.cache_manager.commit(context)
sheerka = self.get_sheerka() # another session
assert sheerka.add_concept_to_set(context, bar, group).status
# I can get the elements
assert set(sheerka.get_set_elements(context, group)) == {foo, bar}
sheerka.cache_manager.commit(context) # save in db
all_entries = sheerka.sdp.get(sheerka.CONCEPTS_GROUPS_ENTRY) # check the db
assert all_entries == {
group.id: {foo.id, bar.id}
}
# I can also add a group another elements
sheerka = self.get_sheerka()
foo3 = Concept("foo3")
foo4 = Concept("foo4")
for c in [foo3, foo4]:
sheerka.create_new_concept(context, c)
res = sheerka.sets_handler.add_concepts_to_set(context, (foo3, foo4), group)
assert res.status
# I can get the elements
assert set(sheerka.get_set_elements(context, group)) == {foo, bar, foo3, foo4}
sheerka.cache_manager.commit(context) # save in db
all_entries = sheerka.sdp.get(sheerka.CONCEPTS_GROUPS_ENTRY) # check the db
assert all_entries == {
group.id: {foo.id, bar.id, foo3.id, foo4.id}
}
def test_i_can_set_isa(self):
sheerka, context, foo, bar, group = self.init_concepts(
"foo",
"bar",
"group",
create_new=True, # needed by modify
)
# nothing was previously in ISA
foo = sheerka.new(foo.key)
assert BuiltinConcepts.ISA not in foo.metadata.props
res = sheerka.set_isa(context, foo, group)
assert res.status
sheerka.cache_manager.commit(context)
sheerka = self.get_sheerka()
assert foo.get_prop(BuiltinConcepts.ISA) == {group}
assert sheerka.isa(foo, group)
assert sheerka.isinset(foo, group)
assert sheerka.isaset(context, group)
# I can do the same for bar
sheerka = self.get_sheerka()
res = sheerka.set_isa(context, bar, group)
assert res.status
assert bar.get_prop(BuiltinConcepts.ISA) == {group}
assert sheerka.isa(bar, group)
assert sheerka.isinset(bar, group)
assert sheerka.isaset(context, group)
sheerka.cache_manager.commit(context)
# they are both in the same group
sheerka = self.get_sheerka()
all_entries = sheerka.sdp.get(sheerka.CONCEPTS_GROUPS_ENTRY)
assert all_entries == {
group.id: {foo.id, bar.id}
}
elements = sheerka.get_set_elements(context, group)
assert set(elements) == {foo, bar}
tests/core/test_SheerkaVariableManager.py
+50 -34
View File
@@ -1,20 +1,23 @@
from core.concept import Concept, ConceptParts
from core.sheerka.Services.SheerkaVariableManager import SheerkaVariableManager
from core.sheerka.Sheerka import Sheerka
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
class TestSheerkaVariable(TestUsingMemoryBasedSheerka):
def test_i_can_record_and_load_a_constant(self):
sheerka = self.get_sheerka()
sheerka = self.get_sheerka(cache_only=False)
context = self.get_context(sheerka)
sheerka.record(context, "TestSheerkaVariable", "my_variable", 1)
res = sheerka.load("TestSheerkaVariable", "my_variable")
assert res == 1
assert sheerka.sdp.exists(SheerkaVariableManager.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
loaded = sheerka.sdp.get(SheerkaVariableManager.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
# I can persist in db
sheerka.cache_manager.commit(context)
assert sheerka.sdp.exists(Sheerka.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
loaded = sheerka.sdp.get(Sheerka.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
assert loaded.event_id == context.event.get_digest()
assert loaded.key == "my_variable"
assert loaded.value == 1
@@ -25,47 +28,60 @@ class TestSheerkaVariable(TestUsingMemoryBasedSheerka):
sheerka = self.get_sheerka()
context = self.get_context(sheerka)
concept = Concept("foo").set_prop("a", "alpha").set_metadata_value(ConceptParts.BODY, 3.14)
concept = Concept("foo").set_value("a", "alpha").set_value(ConceptParts.BODY, 3.14)
sheerka.record(context, "TestSheerkaVariable", "my_variable", concept)
res = sheerka.load("TestSheerkaVariable", "my_variable")
assert res == concept
assert res.body == concept.body
assert res.a == concept.a
def test_i_can_get_the_parent_when_modified(self):
def test_i_can_delete_an_entry(self):
sheerka = self.get_sheerka()
context = self.get_context(sheerka)
sheerka.record(context, "TestSheerkaVariable", "my_variable", 1)
sheerka.record(context, "TestSheerkaVariable", "my_variable", 2)
res = sheerka.load("TestSheerkaVariable", "my_variable")
assert res == 2
concept = Concept("foo")
loaded = sheerka.sdp.get(SheerkaVariableManager.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
assert loaded.event_id == context.event.get_digest()
assert loaded.key == "my_variable"
assert loaded.value == 2
assert loaded.who == "TestSheerkaVariable"
assert loaded.parents == ['8c9ada7bf488d84229f6539f76042431638f16d600fe3b7ec7e7161043a40d59']
sheerka.record(context, "TestSheerkaVariable", "my_variable", concept)
assert sheerka.load("TestSheerkaVariable", "my_variable") is not None
parent = sheerka.sdp.load_obj(loaded.parents[0])
assert parent.event_id == context.event.get_digest()
assert parent.key == "my_variable"
assert parent.value == 1
assert parent.who == "TestSheerkaVariable"
assert parent.parents is None
sheerka.delete(context, "TestSheerkaVariable", "my_variable")
assert sheerka.load("TestSheerkaVariable", "my_variable") is None
def test_variable_is_not_persisted_if_the_value_is_the_same(self):
sheerka = self.get_sheerka()
context = self.get_context(sheerka)
# def test_i_can_get_the_parent_when_modified(self):
# sheerka = self.get_sheerka()
# context = self.get_context(sheerka)
#
# sheerka.record(context, "TestSheerkaVariable", "my_variable", 1)
# sheerka.record(context, "TestSheerkaVariable", "my_variable", 2)
# res = sheerka.load("TestSheerkaVariable", "my_variable")
# assert res == 2
#
# loaded = sheerka.sdp.get(Sheerka.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
# assert loaded.event_id == context.event.get_digest()
# assert loaded.key == "my_variable"
# assert loaded.value == 2
# assert loaded.who == "TestSheerkaVariable"
# assert loaded.parents == ['8c9ada7bf488d84229f6539f76042431638f16d600fe3b7ec7e7161043a40d59']
#
# parent = sheerka.sdp.load_obj(loaded.parents[0])
# assert parent.event_id == context.event.get_digest()
# assert parent.key == "my_variable"
# assert parent.value == 1
# assert parent.who == "TestSheerkaVariable"
# assert parent.parents is None
sheerka.record(context, "TestSheerkaVariable", "my_variable", 1)
sheerka.record(context, "TestSheerkaVariable", "my_variable", 1)
loaded = sheerka.sdp.get(SheerkaVariableManager.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
assert loaded.event_id == context.event.get_digest()
assert loaded.key == "my_variable"
assert loaded.value == 1
assert loaded.who == "TestSheerkaVariable"
assert loaded.parents is None
# def test_variable_is_not_persisted_if_the_value_is_the_same(self):
# sheerka = self.get_sheerka(singleton=True)
# context = self.get_context(sheerka)
#
# sheerka.record(context, "TestSheerkaVariable", "my_variable", 1)
# sheerka.record(context, "TestSheerkaVariable", "my_variable", 1)
#
# loaded = sheerka.sdp.get(Sheerka.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
# assert loaded.event_id == context.event.get_digest()
# assert loaded.key == "my_variable"
# assert loaded.value == 1
# assert loaded.who == "TestSheerkaVariable"
# assert loaded.parents is None
tests/core/test_ast.py
+18 -19
View File
@@ -1,16 +1,15 @@
import ast
import pytest
from core.ast.nodes import NodeParent, GenericNodeConcept
import core.ast.nodes
import pytest
from core.ast.nodes import NodeParent, GenericNodeConcept
from core.ast.visitors import ConceptNodeVisitor, UnreferencedNamesVisitor
from core.builtin_concepts import BuiltinConcepts
from core.sheerka.Sheerka import Sheerka
def get_sheerka():
sheerka = Sheerka(skip_builtins_in_db=True)
sheerka = Sheerka(cache_only=True)
sheerka.initialize("mem://")
return sheerka
@@ -40,32 +39,32 @@ def my_function(a,b):
sheerka = get_sheerka()
assert tree_as_concept.node_type == "Module"
assert sheerka.isinstance(tree_as_concept.get_prop("body"), BuiltinConcepts.LIST)
assert sheerka.isinstance(tree_as_concept.get_value("body"), BuiltinConcepts.LIST)
def_func = tree_as_concept.get_prop("body").body[0]
def_func = tree_as_concept.get_value("body").body[0]
assert sheerka.isinstance(def_func, BuiltinConcepts.GENERIC_NODE)
assert def_func.node_type == "FunctionDef"
assert def_func.parent == NodeParent(tree_as_concept, "body")
assert def_func.get_prop("name") == "my_function"
assert def_func.get_value("name") == "my_function"
def_func_args = def_func.get_prop("args")
def_func_args = def_func.get_value("args")
assert sheerka.isinstance(def_func_args, BuiltinConcepts.GENERIC_NODE)
assert def_func_args.node_type == "arguments"
def_func_args_real_args = def_func_args.get_prop("args")
def_func_args_real_args = def_func_args.get_value("args")
assert sheerka.isinstance(def_func_args_real_args, BuiltinConcepts.LIST)
assert len(def_func_args_real_args.body) == 2
assert sheerka.isinstance(def_func_args_real_args.body[0], BuiltinConcepts.GENERIC_NODE)
assert def_func_args_real_args.body[0].node_type == "arg"
assert def_func_args_real_args.body[0].parent == NodeParent(def_func_args, "args")
assert def_func_args_real_args.body[0].get_prop("arg") == "a"
assert def_func_args_real_args.body[0].get_value("arg") == "a"
assert sheerka.isinstance(def_func_args_real_args.body[1], BuiltinConcepts.GENERIC_NODE)
assert def_func_args_real_args.body[1].node_type == "arg"
assert def_func_args_real_args.body[1].parent == NodeParent(def_func_args, "args")
assert def_func_args_real_args.body[1].get_prop("arg") == "b"
assert def_func_args_real_args.body[1].get_value("arg") == "b"
def_fun_body = def_func.get_prop("body")
def_fun_body = def_func.get_value("body")
assert sheerka.isinstance(def_fun_body, BuiltinConcepts.LIST)
assert len(def_fun_body.body) == 2
@@ -95,13 +94,13 @@ def my_function(a,b):
visitor.visit(concept_node)
sheerka = get_sheerka()
assert sheerka.value(visitor.names[0]) == "i"
assert sheerka.value(visitor.names[1]) == "range"
assert sheerka.value(visitor.names[2]) == "b"
assert sheerka.value(visitor.names[3]) == "a"
assert sheerka.value(visitor.names[4]) == "a"
assert sheerka.value(visitor.names[5]) == "b"
assert sheerka.value(visitor.names[6]) == "a"
assert sheerka.objvalue(visitor.names[0]) == "i"
assert sheerka.objvalue(visitor.names[1]) == "range"
assert sheerka.objvalue(visitor.names[2]) == "b"
assert sheerka.objvalue(visitor.names[3]) == "a"
assert sheerka.objvalue(visitor.names[4]) == "a"
assert sheerka.objvalue(visitor.names[5]) == "b"
assert sheerka.objvalue(visitor.names[6]) == "a"
def test_i_can_get_unreferenced_variables():
tests/core/test_builtin_helpers.py
+2 -2
View File
@@ -1,7 +1,7 @@
import ast
import pytest
import core.builtin_helpers
import core.builtin_helpers
import pytest
from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
tests/core/test_concept.py
+47 -24
View File
@@ -3,7 +3,7 @@ import pytest
from core.concept import Concept, ConceptParts, DEFINITION_TYPE_DEF
@pytest.mark.parametrize("name, properties, expected", [
@pytest.mark.parametrize("name, variables, expected", [
("foo", [], "foo"),
("foo(bar)", [], "foo ( bar )"),
("foo a", ["a"], "foo __var__0"),
@@ -20,21 +20,20 @@ from core.concept import Concept, ConceptParts, DEFINITION_TYPE_DEF
("a b a c", ["a", "b"], "__var__0 __var__1 __var__0 c"),
("a b a c", ["b", "a"], "__var__1 __var__0 __var__1 c"),
])
def test_i_can_compute_the_key(name, properties, expected):
def test_i_can_compute_the_key(name, variables, expected):
concept = Concept(name)
for prop in properties:
concept.metadata.props.append((prop, None))
for var_name in variables:
concept.metadata.variables.append((var_name, None))
concept.init_key()
assert concept.key == expected
def test_i_can_compute_the_key_when_from_definition():
# if definition is not defined, use the name
concept = Concept()
concept.metadata.name = "hello a"
concept.metadata.props = [("a", None)]
concept.metadata.variables = [("a", None)]
concept.init_key()
assert concept.key == "hello __var__0"
@@ -43,13 +42,13 @@ def test_i_can_compute_the_key_when_from_definition():
concept.metadata.name = "greetings"
concept.metadata.definition = "hello a"
concept.metadata.definition_type = DEFINITION_TYPE_DEF
concept.metadata.props = [("a", None)]
concept.metadata.variables = [("a", None)]
concept.init_key()
assert concept.key == "hello __var__0"
def test_key_does_not_use_variable_when_definition_is_set():
concept = Concept("plus").def_prop('plus')
concept = Concept("plus").def_var('plus')
concept.init_key()
assert concept.metadata.key == "plus"
@@ -73,7 +72,7 @@ def test_i_can_serialize():
definition_type="def type",
desc="this this the desc",
id="123456"
).def_prop("a", "10").def_prop("b", None)
).def_var("a", "10").def_var("b", None)
to_dict = concept.to_dict()
assert to_dict == {
@@ -88,7 +87,8 @@ def test_i_can_serialize():
'name': 'concept_name',
'post': 'definition of the post',
'pre': 'definition of the pre',
'props': [('a', "10"), ('b', None)],
'props': {},
'variables': [('a', "10"), ('b', None)],
'where': 'definition of the where'
}
@@ -111,7 +111,8 @@ def test_i_can_deserialize():
'name': 'concept_name',
'post': 'definition of the post',
'pre': 'definition of the pre',
'props': [('a', "10"), ('b', None)],
'props': {},
'variables': [('a', "10"), ('b', None)],
'where': 'definition of the where'
}
@@ -130,16 +131,16 @@ def test_i_can_deserialize():
definition_type="def type",
desc="this this the desc",
id="123456"
).def_prop("a", "10").def_prop("b", None)
).def_var("a", "10").def_var("b", None)
def test_i_can_deserialize_props_coming_from_sdp():
def test_i_can_deserialize_variables_coming_from_sdp():
from_dict = {
'props': [['a', "10"], ['b', None]], # JSON transform set into list
'variables': [['a', "10"], ['b', None]], # JSON transform set into list
}
concept = Concept().from_dict(from_dict)
assert concept == Concept().def_prop("a", "10").def_prop("b", None)
assert concept == Concept().def_var("a", "10").def_var("b", None)
def test_i_can_compare_concepts():
@@ -156,7 +157,7 @@ def test_i_can_compare_concepts():
definition_type="def type",
desc="this this the desc",
id="123456"
).def_prop("a", "10").def_prop("b", None)
).def_var("a", "10").def_var("b", None).add_prop("prop", "prop_val")
concept_b = Concept(
name="concept_name",
@@ -171,11 +172,33 @@ def test_i_can_compare_concepts():
definition_type="def type",
desc="this this the desc",
id="123456"
).def_prop("a", "10").def_prop("b", None)
).def_var("a", "10").def_var("b", None).add_prop("prop", "prop_val")
assert concept_a == concept_b
def test_i_can_detect_concept_differences():
assert Concept(name="concept_name") != Concept()
assert Concept(is_builtin=True) != Concept()
assert Concept(is_unique=True) != Concept()
assert Concept(key="concept_key") != Concept()
assert Concept(body="concept_body") != Concept()
assert Concept(where="concept_where") != Concept()
assert Concept(pre="concept_pre") != Concept()
assert Concept(post="concept_post") != Concept()
assert Concept(definition="def") != Concept()
assert Concept(definition_type="def type") != Concept()
assert Concept(desc="desc") != Concept()
assert Concept(id="concept_id") != Concept()
assert Concept().def_var("a") != Concept()
assert Concept().add_prop("a", "b") != Concept()
assert Concept().set_value("a", "b") != Concept()
concept = Concept()
concept.compiled["foo"] = "value"
assert concept == Concept() # compiled is not used in the comparison
def test_i_can_compare_concept_with_circular_reference():
foo = Concept("foo")
foo.metadata.body = foo
@@ -215,17 +238,17 @@ def test_i_can_update_from():
definition_type="def type",
desc="this this the desc",
id="123456"
).def_prop("a", "10").def_prop("b", None)
).def_var("a", "10").def_var("b", None)
# make sure origin is preserved
setattr(template, "##origin##", "digest")
template.values[ConceptParts.BODY] = "value in body"
template.values[ConceptParts.WHERE] = "value in where"
template.values[ConceptParts.PRE] = "value in pre"
template.values[ConceptParts.POST] = "value in post"
template.set_prop("a", 10)
template.set_prop("b", 20)
template.set_value(ConceptParts.BODY, "value in body")
template.set_value(ConceptParts.WHERE, "value in where")
template.set_value(ConceptParts.PRE, "value in pre")
template.set_value(ConceptParts.POST, "value in post")
template.set_value("a", 10)
template.set_value("b", 20)
concept = Concept().update_from(template)
tests/core/test_sheerka.py
+218 -103
View File
@@ -1,24 +1,33 @@
import pytest
import os
import pytest
from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, UserInputConcept
from core.concept import Concept, PROPERTIES_TO_SERIALIZE
from core.sheerka.Sheerka import Sheerka
from core.concept import Concept, PROPERTIES_TO_SERIALIZE, ConceptParts
from core.sheerka.Sheerka import Sheerka, BASE_NODE_PARSER_CLASS
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
class ConceptWithGetValue(Concept):
def get_value(self):
return self.get_prop("my_prop")
class ConceptWithGetObjValue(Concept):
def get_obj_value(self):
return self.get_value("my_prop")
class TestSheerka(TestUsingFileBasedSheerka):
class TestSheerkaUsingMemoryBasedSheerka(TestUsingMemoryBasedSheerka):
def test_root_folder_is_created_after_initialization(self):
return_value = Sheerka().initialize(self.root_folder)
assert return_value.status, "initialisation should be successful"
assert os.path.exists(self.root_folder), "init folder should be created"
def test_i_can_initialize_builtin_parsers(self):
sheerka = self.get_sheerka()
# test existence of some parser (not all)
assert "parsers.DefaultParser.DefaultParser" in sheerka.parsers
assert "parsers.BnfNodeParser.BnfNodeParser" in sheerka.parsers
assert "parsers.SyaNodeParser.SyaNodeParser" in sheerka.parsers
assert "parsers.AtomNodeParser.AtomNodeParser" in sheerka.parsers
# make sure BaseNodeParser is properly initialized
assert BASE_NODE_PARSER_CLASS not in sheerka.parsers
assert sheerka.bnp is not None
def test_i_can_list_builtin_concepts(self):
sheerka = self.get_sheerka()
@@ -27,27 +36,6 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert str(BuiltinConcepts.ERROR) in builtins
assert str(BuiltinConcepts.RETURN_VALUE) in builtins
def test_builtin_concepts_are_initialized(self):
sheerka = self.get_sheerka(skip_builtins_in_db=False)
assert len(sheerka.cache_by_key) == len(BuiltinConcepts)
for concept_name in BuiltinConcepts:
assert str(concept_name) in sheerka.cache_by_key
assert sheerka.sdp.get_safe(sheerka.CONCEPTS_ENTRY, str(concept_name)) is not None
for key, concept_class in sheerka.get_builtins_classes_as_dict().items():
assert isinstance(sheerka.cache_by_key[key], concept_class)
def test_builtin_concepts_can_be_updated(self):
sheerka = self.get_sheerka(use_dict=False, skip_builtins_in_db=False)
loaded_sheerka = sheerka.get(BuiltinConcepts.SHEERKA)
loaded_sheerka.metadata.desc = "I have a description"
sheerka.sdp.modify("Test", sheerka.CONCEPTS_ENTRY, loaded_sheerka.key, loaded_sheerka)
sheerka = self.get_sheerka(use_dict=False, skip_builtins_in_db=False)
loaded_sheerka = sheerka.get(BuiltinConcepts.SHEERKA)
assert loaded_sheerka.metadata.desc == "I have a description"
def test_i_can_get_a_builtin_concept_by_their_enum_or_the_string(self):
"""
Checks that a concept can be found its name
@@ -56,27 +44,27 @@ class TestSheerka(TestUsingFileBasedSheerka):
"""
sheerka = self.get_sheerka()
for key in sheerka.get_builtins_classes_as_dict():
assert sheerka.get(key) is not None
assert sheerka.get(str(key)) is not None
assert sheerka.get_by_key(key) is not None
assert sheerka.get_by_key(str(key)) is not None
def test_i_cannot_get_when_key_is_none(self):
sheerka = self.get_sheerka()
res = sheerka.get(None)
res = sheerka.get_by_key(None)
assert sheerka.isinstance(res, BuiltinConcepts.ERROR)
assert res.body == "Concept key is undefined."
assert res.body == "Concept 'None' is undefined."
def test_unknown_concept_is_return_when_the_concept_key_is_not_found(self):
def test_i_cannot_get_when_key_is_not_found(self):
sheerka = self.get_sheerka()
loaded = sheerka.get("key_that_does_not_exist")
loaded = sheerka.get_by_key("key_that_does_not_exist")
assert loaded is not None
assert sheerka.isinstance(loaded, BuiltinConcepts.UNKNOWN_CONCEPT)
assert loaded.body == ("key", "key_that_does_not_exist")
assert loaded.metadata.is_evaluated
def test_unknown_concept_is_return_when_the_concept_id_is_not_found(self):
def test_i_cannot_get_when_id_is_not_found(self):
sheerka = self.get_sheerka()
loaded = sheerka.get_by_id("id_that_does_not_exist")
@@ -97,6 +85,10 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert ret.value == "value"
assert ret.message == "message"
# check the others
for key, concept_class in sheerka.get_builtins_classes_as_dict().items():
assert isinstance(sheerka.get_by_key(key), concept_class)
def test_i_can_instantiate_a_builtin_concept_when_no_specific_class(self):
sheerka = self.get_sheerka()
ret = sheerka.new(BuiltinConcepts.UNKNOWN_CONCEPT, body="fake_concept")
@@ -106,9 +98,7 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert ret.body == "fake_concept"
def test_i_can_instantiate_a_concept(self):
sheerka = self.get_sheerka()
concept = self.get_default_concept()
sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka, context, concept = self.init_concepts(self.get_default_concept(), create_new=True)
new = sheerka.new(concept.key, a=10, b="value")
@@ -116,27 +106,33 @@ class TestSheerka(TestUsingFileBasedSheerka):
for prop in PROPERTIES_TO_SERIALIZE:
assert getattr(new.metadata, prop) == getattr(concept.metadata, prop)
assert new.props["a"].value == 10
assert new.props["b"].value == "value"
assert new.get_value("a") == 10
assert new.get_value("b") == "value"
def test_i_can_instantiate_with_the_name_and_the_id(self):
sheerka = self.get_sheerka()
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="foo1"))
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="foo2"))
def test_i_can_instantiate_multiple_when_same_key(self):
sheerka, context, *concepts = self.init_concepts(
Concept("foo", body="foo1"),
Concept("foo", body="foo2"),
create_new=True)
# when no id, i get two instances
concepts = sheerka.new("foo")
assert len(concepts) == 2
assert concepts[0].id == "1001"
assert concepts[0].metadata.body == "foo1"
assert concepts[1].id == "1002"
assert concepts[1].metadata.body == "foo2"
# only one instance if the id is given
foo1 = sheerka.new(("foo", "1001"))
assert foo1.metadata.body == "foo1"
# only one instance if the id is given
foo2 = sheerka.new(("foo", "1002"))
assert foo2.metadata.body == "foo2"
def test_instances_are_different_when_asking_for_new(self):
sheerka = self.get_sheerka()
concept = self.get_default_concept()
sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka, context, concept = self.init_concepts(self.get_default_concept(), create_new=True)
new1 = sheerka.new(concept.key, a=10, b="value")
new2 = sheerka.new(concept.key, a=10, b="value")
@@ -144,17 +140,50 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert new1 == new2
assert id(new1) != id(new2)
def test_i_get_the_same_instance_when_is_unique_is_true(self):
sheerka = self.get_sheerka()
concept = Concept(name="unique", is_unique=True)
sheerka.create_new_concept(self.get_context(sheerka), concept)
def test_new_instance_does_not_impact_each_others(self):
sheerka, context, foo, bar = self.init_concepts("foo", "bar", create_new=True)
new1 = sheerka.new(concept.key, a=10, b="value")
new2 = sheerka.new(concept.key, a=10, b="value")
new_foo = sheerka.new("foo")
new_foo.metadata.body = "metadata value" # modify metadata
new_foo.def_var("var_name", "default value") # modify definition of variables
new_foo.add_prop(BuiltinConcepts.ISA, bar) # modify property
new_foo.compiled["var_name"] = "'var value'"
new_foo.set_value(ConceptParts.BODY, "body value") # modify value
new_foo.set_value("var_name", "var value") # modify value
assert new_foo.metadata.body != foo.metadata.body
assert new_foo.metadata.variables != foo.metadata.variables
assert new_foo.metadata.props != foo.metadata.props
assert new_foo.values != foo.values
assert new_foo.compiled != foo.compiled
def test_i_get_the_same_instance_when_is_unique_is_true(self):
sheerka, context, concept = self.init_concepts(Concept(name="unique", is_unique=True), create_new=True)
new1 = sheerka.new(concept.key)
new2 = sheerka.new(concept.key, a=10, b="value") # not that variables are simply discareded
assert new1 == new2
assert id(new1) == id(new2)
def test_values_are_reset_when_asking_for_a_new_instance(self):
sheerka, context, template = self.init_concepts(
Concept("foo", body="'foo body'"),
create_new=True,
eval_body=True)
sheerka.evaluate_concept(context, sheerka.get_by_id(template.id))
assert template.metadata.is_evaluated
assert template.body == "foo body"
new = sheerka.new(template.key)
assert not new.metadata.is_evaluated
assert not new.body
new = sheerka.new((None, template.id))
assert not new.metadata.is_evaluated
assert not new.body
def test_i_cannot_instantiate_an_unknown_concept(self):
sheerka = self.get_sheerka()
@@ -164,9 +193,10 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert new.body == ('key', 'fake_concept')
def test_i_cannot_instantiate_with_invalid_id(self):
sheerka = self.get_sheerka()
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="foo1"))
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="foo2"))
sheerka, context, *concepts = self.init_concepts(
Concept("foo", body="foo1"),
Concept("foo", body="foo2"),
create_new=True)
new = sheerka.new(("foo", "invalid_id"))
@@ -174,9 +204,10 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert new.body == [('key', 'foo'), ('id', 'invalid_id')]
def test_i_cannot_instantiate_with_invalid_key(self):
sheerka = self.get_sheerka()
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="foo1"))
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="foo2"))
sheerka, context, *concepts = self.init_concepts(
Concept("foo", body="foo1"),
Concept("foo", body="foo2"),
create_new=True)
new = sheerka.new(("invalid_key", "1001"))
@@ -184,8 +215,9 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert new.body == [('key', 'invalid_key'), ('id', '1001')]
def test_concept_id_is_irrelevant_when_only_one_concept(self):
sheerka = self.get_sheerka()
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="foo1"))
sheerka, context, *concepts = self.init_concepts(
Concept("foo", body="foo1"),
create_new=True)
new = sheerka.new(("foo", "invalid_id"))
@@ -193,9 +225,7 @@ class TestSheerka(TestUsingFileBasedSheerka):
assert new.metadata.body == "foo1"
def test_i_cannot_instantiate_when_properties_are_not_recognized(self):
sheerka = self.get_sheerka()
concept = self.get_default_concept()
sheerka.create_new_concept(self.get_context(sheerka), concept)
sheerka, context, concept = self.init_concepts(self.get_default_concept(), create_new=True)
new = sheerka.new(concept.key, a=10, c="value")
@@ -210,7 +240,7 @@ class TestSheerka(TestUsingFileBasedSheerka):
(True, False, True),
(Concept("name", body="foo"), False, "foo"),
(Concept("name"), False, Concept("name")),
(ConceptWithGetValue("name").set_prop("my_prop", "my_value"), False, "my_value"),
(ConceptWithGetObjValue("name").set_value("my_prop", "my_value"), False, "my_value"),
(ReturnValueConcept(value="return_value"), False, "return_value"),
(ReturnValueConcept(value=Concept(key=BuiltinConcepts.USER_INPUT, body="text"), status=True), False, "text"),
(ReturnValueConcept(value=UserInputConcept("text"), status=True), False, "text"),
@@ -230,53 +260,138 @@ class TestSheerka(TestUsingFileBasedSheerka):
c.auto_init()
c = c.body
assert sheerka.value(concept, reduce_simple_list) == expected
def test_list_of_concept_is_sorted_by_id(self):
sheerka = self.get_sheerka(use_dict=False, skip_builtins_in_db=False)
concepts = sheerka.concepts()
assert concepts[0].id < concepts[-1].id
assert sheerka.objvalue(concept, reduce_simple_list) == expected
def test_builtin_error_concept_are_errors(self):
# only test a random one, it will be the same for the others
sheerka = self.get_sheerka()
assert not sheerka.is_success(sheerka.new(BuiltinConcepts.TOO_MANY_SUCCESS))
def test_cache_is_updated_after_get(self):
sheerka = self.get_sheerka(skip_builtins_in_db=False)
# updated when by_key returns one element
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="1"))
sheerka.reset_cache()
sheerka.get("foo")
assert "foo" in sheerka.cache_by_key
assert "1001" in sheerka.cache_by_id
class TestSheerkaUsingFileBasedSheerka(TestUsingFileBasedSheerka):
# updated when by_key returns two elements
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="2"))
sheerka.reset_cache()
sheerka.get("foo")
assert "foo" in sheerka.cache_by_key
assert "1001" in sheerka.cache_by_id
assert "1002" in sheerka.cache_by_id
def test_root_folder_is_created_after_initialization(self):
return_value = Sheerka().initialize(self.root_folder)
assert return_value.status, "initialisation should be successful"
assert os.path.exists(self.root_folder), "init folder should be created"
def test_builtin_concepts_are_initialized(self):
sheerka = self.get_sheerka()
for concept_name in BuiltinConcepts:
assert sheerka.has_key(str(concept_name))
assert sheerka.sdp.get(sheerka.CONCEPTS_BY_KEY_ENTRY, str(concept_name)) is not None
# I can get back data from the sdp when the cache is empty
sheerka.cache_manager.clear()
# caches are empty
assert not sheerka.has_id("1")
assert not sheerka.has_key(str(BuiltinConcepts.SHEERKA))
assert sheerka.get_by_id("1") == sheerka # use sdp
# assert sheerka.has_key(str(BuiltinConcepts.SHEERKA)) # auto update the other caches
def test_builtin_concepts_can_be_updated(self):
sheerka = self.get_sheerka()
before_parsing = sheerka.get_by_key(BuiltinConcepts.BEFORE_PARSING)
before_parsing.metadata.desc = "I have a description"
before_parsing.metadata.full_serialization = True
with sheerka.sdp.get_transaction("Test") as transac:
transac.add(sheerka.CONCEPTS_BY_KEY_ENTRY, before_parsing.key, before_parsing, use_ref=True)
sheerka = self.get_sheerka() # another fresh new instance
before_parsing = sheerka.get_by_key(BuiltinConcepts.BEFORE_PARSING)
assert before_parsing.metadata.desc == "I have a description"
def test_i_first_look_in_local_cache(self):
sheerka, context, concept = self.init_concepts("foo", create_new=True)
sheerka.cache_manager.commit(context)
sheerka.get_by_key(concept.key).new_property = "I have modified the concept in cache"
from_cache = sheerka.get_by_key(concept.key)
assert from_cache is not None
assert from_cache.key == concept.key
assert from_cache.new_property == "I have modified the concept in cache"
# sdp instance is not modified
sheerka.cache_manager.clear()
from_sdp = sheerka.get_by_key(concept.key)
assert from_sdp is not None
assert from_sdp.key == concept.key
assert not hasattr(from_sdp, "new_property")
def test_i_can_retrieve_from_sdp_when_cache_is_reset(self):
sheerka, context, concept = self.init_concepts(Concept("foo", body="1"))
sheerka.cache_manager.commit(context)
sheerka.cache_manager.clear()
sheerka.get_by_key("foo")
assert sheerka.has_key("foo")
# It's also updated when sdp returns more than one element
concept2 = Concept("foo", body="2")
sheerka.create_new_concept(context, concept2)
sheerka.cache_manager.commit(context)
sheerka.cache_manager.clear()
assert len(sheerka.get_by_key("foo")) == 2
assert sheerka.has_key("foo")
# updated when by_id
sheerka.reset_cache()
sheerka.get_by_id("1001")
assert "1001" in sheerka.cache_by_id
assert "foo" not in sheerka.cache_by_key # cache_by_key not updated as "1001" is not the only one
sheerka.cache_manager.clear()
assert sheerka.get_by_id("1001") == concept
assert sheerka.has_id("1001")
def test_i_can_get_by_key_several_times(self):
sheerka = self.get_sheerka()
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="1"))
sheerka.create_new_concept(self.get_context(sheerka), Concept("foo", body="2"))
sheerka.cache_manager.clear()
assert sheerka.get_by_name("foo") == [concept, concept2]
assert sheerka.has_name("foo")
sheerka.reset_cache()
sheerka.get("foo", "1001") # only one element requested. But the cache must be updated with two elements
sheerka.cache_manager.clear()
assert sheerka.get_by_hash(concept.get_definition_hash()) == concept
assert sheerka.has_hash(concept.get_definition_hash())
# let's check it
concepts = sheerka.get("foo")
def test_get_by_key_retrieve_all_elements(self):
sheerka, context, *concepts = self.init_concepts(
Concept("foo", body="1"),
Concept("foo", body="2"),
create_new=True)
sheerka.cache_manager.commit(context)
sheerka.cache_manager.clear()
sheerka.get_by_key("foo", "1001") # I ask only for the one with id = "1001"
# but the two keys are returned
concepts = sheerka.get_by_key("foo")
assert len(concepts) == 2
assert concepts[0].id == "1001"
assert concepts[1].id == "1002"
def test_concept_node_parsing_is_initialized_at_startup(self):
sheerka, context, foo, bar, baz = self.init_concepts(
"foo",
"bar",
Concept("baz", definition="foo"),
create_new=True)
sheerka.cache_manager.commit(context)
assert sheerka.cache_manager.copy(sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY) == {
'bar': ['1002'],
'c:|1001:': ['1003'],
'foo': ['1001']}
assert sheerka.cache_manager.copy(sheerka.RESOLVED_CONCEPTS_BY_FIRST_KEYWORD_ENTRY) == {
'bar': ['1002'],
'foo': ['1001', '1003']
}
sheerka = self.get_sheerka() # another instance
assert sheerka.cache_manager.copy(sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY) == {
'bar': ['1002'],
'c:|1001:': ['1003'],
'foo': ['1001']}
assert sheerka.cache_manager.copy(sheerka.RESOLVED_CONCEPTS_BY_FIRST_KEYWORD_ENTRY) == {
'bar': ['1002'],
'foo': ['1001', '1003']
}
tests/core/test_sheerka_call_evaluators.py
+6
View File
@@ -189,6 +189,12 @@ class EvaluatorAllSuppressFooEntry(EvaluatorAllWithPriority):
class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
@classmethod
def teardown_class(cls):
# At the end of the tests, sheerka singleton instance will be corrupted
# Ask for a new one
TestUsingMemoryBasedSheerka.singleton_instance = None
def test_that_return_values_is_unchanged_when_no_evaluator(self):
sheerka = self.get_sheerka()
sheerka.evaluators = []
tests/core/test_sheerka_call_parsers.py
+5
View File
@@ -135,6 +135,11 @@ class ListOfNoneParser(BaseTestParser):
class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
@classmethod
def teardown_class(cls):
# At the end of the tests, sheerka singleton instance will be corrupted
# Ask for a new one
TestUsingMemoryBasedSheerka.singleton_instance = None
def test_disabled_parsers_are_not_executed(self):
sheerka = self.get_sheerka()
tests/core/test_sheerka_printer.py
+15 -14
View File
@@ -22,6 +22,7 @@ class ObjLongProp:
class TestSheerkaPrinter(TestUsingMemoryBasedSheerka):
@pytest.mark.parametrize("text, expected", [
("Hello world!", "Hello world!\n"),
("%black%%red%%green%%yellow%%reset%", "\x1b[30m\x1b[31m\x1b[32m\x1b[33m\x1b[0m\n"),
@@ -45,7 +46,7 @@ class TestSheerkaPrinter(TestUsingMemoryBasedSheerka):
def test_i_can_print_concept(self, capsys):
sheerka = self.get_sheerka()
foo = Concept("foo a b").def_prop("a").def_prop("b")
foo = Concept("foo a b").def_var("a").def_var("b")
sheerka.print(foo)
captured = capsys.readouterr()
@@ -53,11 +54,11 @@ class TestSheerkaPrinter(TestUsingMemoryBasedSheerka):
def test_i_can_use_custom_format(self, capsys):
sheerka = self.get_sheerka()
foo = Concept("foo a b").def_prop("a").def_prop("b").init_key()
foo = Concept("foo a b").def_var("a").def_var("b").init_key()
sheerka.printer_handler.register_custom_printer(
foo,
lambda printer, instr, item: printer.fp(instr, f"foo a={item.a}, b={item.b}"))
foo.set_prop("a", "value a").set_prop("b", "value b")
foo.set_value("a", "value a").set_value("b", "value b")
sheerka.print(foo)
captured = capsys.readouterr()
@@ -66,8 +67,8 @@ class TestSheerkaPrinter(TestUsingMemoryBasedSheerka):
def test_i_can_print_and_recurse(self, capsys):
sheerka = self.get_sheerka()
level3 = Concept("level3")
level2 = Concept("level2").set_metadata_value(ConceptParts.BODY, level3)
level1 = Concept("level1").set_metadata_value(ConceptParts.BODY, level2)
level2 = Concept("level2").set_value(ConceptParts.BODY, level3)
level1 = Concept("level1").set_value(ConceptParts.BODY, level2)
sheerka.print(level1)
captured = capsys.readouterr()
@@ -90,9 +91,9 @@ class TestSheerkaPrinter(TestUsingMemoryBasedSheerka):
level31 = Concept("level31")
level32 = Concept("level32")
level33 = Concept("level33")
level21 = Concept("level21").set_metadata_value(ConceptParts.BODY, [level31, level32])
level22 = Concept("level22").set_metadata_value(ConceptParts.BODY, [level33])
level1 = Concept("level1").set_metadata_value(ConceptParts.BODY, [level21, level22])
level21 = Concept("level21").set_value(ConceptParts.BODY, [level31, level32])
level22 = Concept("level22").set_value(ConceptParts.BODY, [level33])
level1 = Concept("level1").set_value(ConceptParts.BODY, [level21, level22])
sheerka.print(level1)
captured = capsys.readouterr()
@@ -111,9 +112,9 @@ class TestSheerkaPrinter(TestUsingMemoryBasedSheerka):
level31 = Concept("level31")
level32 = Concept("level32")
level33 = Concept("level33")
level21 = Concept("level21").set_metadata_value(ConceptParts.BODY, [level31, level32])
level22 = Concept("level22").set_metadata_value(ConceptParts.BODY, [level33])
level1 = Concept("level1").set_metadata_value(ConceptParts.BODY, [level21, level22])
level21 = Concept("level21").set_value(ConceptParts.BODY, [level31, level32])
level22 = Concept("level22").set_value(ConceptParts.BODY, [level33])
level1 = Concept("level1").set_value(ConceptParts.BODY, [level21, level22])
instructions = FormatInstructions(no_color=True)
explanation = sheerka.new(
@@ -150,9 +151,9 @@ class TestSheerkaPrinter(TestUsingMemoryBasedSheerka):
def test_i_can_format_concept(self, capsys):
sheerka = self.get_sheerka()
foo = Concept("foo a b").def_prop("a").def_prop("b").init_key()
foo.set_prop("a", "value a").set_prop("b", "value b")
foo.set_metadata_value(ConceptParts.BODY, "body")
foo = Concept("foo a b").def_var("a").def_var("b").init_key()
foo.set_value("a", "value a").set_value("b", "value b")
foo.set_value(ConceptParts.BODY, "body")
sheerka.set_id_if_needed(foo, False)
sheerka.printer_handler.register_format_l(foo, "{id}-{name}-{key}-{body}-{a}-{b}")
tests/core/test_utils.py
+4 -2
View File
@@ -69,13 +69,13 @@ def test_i_can_get_sub_classes():
default_parser = core.utils.get_class("parsers.DefaultParser.DefaultParser")
exact_concept_parser = core.utils.get_class("parsers.ExactConceptParser.ExactConceptParser")
python_parser = core.utils.get_class("parsers.PythonParser.PythonParser")
concept_lexer_parser = core.utils.get_class("parsers.BnfNodeParser.BnfNodeParser")
bnf_node_parser = core.utils.get_class("parsers.BnfNodeParser.BnfNodeParser")
assert base_parser not in sub_classes
assert default_parser in sub_classes
assert exact_concept_parser in sub_classes
assert python_parser in sub_classes
assert concept_lexer_parser in sub_classes
assert bnf_node_parser in sub_classes
@pytest.mark.parametrize("a,b, expected", [
@@ -170,12 +170,14 @@ def test_i_can_str_concept():
assert core.utils.str_concept((None, "id")) == "c:|id:"
assert core.utils.str_concept(("key", None)) == "c:key:"
assert core.utils.str_concept((None, None)) == ""
assert core.utils.str_concept(("key", "id"), skip_key=True) == "c:|id:"
concept = Concept("foo").init_key()
assert core.utils.str_concept(concept) == "c:foo:"
concept.metadata.id = "1001"
assert core.utils.str_concept(concept) == "c:foo|1001:"
assert core.utils.str_concept(concept, skip_key=True) == "c:|1001:"
@pytest.mark.parametrize("text, expected", [