We can now use concept sets in BNF definitions

tests/test_sheerka.py

@@ -76,13 +76,13 @@ def test_i_can_list_builtin_concepts():
 
 def test_builtin_concepts_are_initialized():
     sheerka = get_sheerka(skip_builtins_in_db=False)
-    assert len(sheerka.concepts_cache) == len(BuiltinConcepts)
+    assert len(sheerka.cache_by_key) == len(BuiltinConcepts)
     for concept_name in BuiltinConcepts:
-        assert str(concept_name) in sheerka.concepts_cache
+        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.concepts_cache[key], concept_class)
+        assert isinstance(sheerka.cache_by_key[key], concept_class)
 
 
 def test_builtin_concepts_can_be_updated():
@@ -113,7 +113,8 @@ def test_i_can_add_a_concept():
     assert concept_found.key == "__var__0 + __var__1"
     assert concept_found.id == "1001"
 
-    assert concept.key in sheerka.concepts_cache
+    assert concept.key in sheerka.cache_by_key
+    assert concept.id in sheerka.cache_by_id
     assert sheerka.sdp.io.exists(
         sheerka.sdp.io.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_found.get_digest()))
 
@@ -154,7 +155,10 @@ def test_i_can_get_a_newly_created_concept():
 
     from_cache = sheerka.get(concept.key)
     assert from_cache is not None
-    assert from_cache.key == concept.key
+    assert from_cache == concept
+
+    from_cache = sheerka.get_by_id(concept.id)
+    assert from_cache is not None
     assert from_cache == concept
 
 
@@ -163,7 +167,7 @@ def test_i_first_look_in_local_cache():
     concept = get_default_concept()
 
     sheerka.create_new_concept(get_context(sheerka), concept)
-    sheerka.concepts_cache[concept.key].pre = "I have modified the concept in cache"
+    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
@@ -180,12 +184,29 @@ def test_i_can_get_a_known_concept_when_not_in_cache():
     concept = get_default_concept()
     sheerka.create_new_concept(get_context(sheerka), concept)
 
-    sheerka.concepts_cache = {}  # reset the cache
+    sheerka.cache_by_key = {}  # reset the cache
     loaded = sheerka.get(concept.key)
 
     assert loaded is not None
     assert loaded == concept
 
+    # I can also get it by its id
+    loaded = sheerka.sdp.get(sheerka.CONCEPTS_BY_ID_ENTRY, concept.id)
+    assert loaded is not None
+    assert loaded == concept
+
+
+def test_i_can_get_a_concept_by_its_id():
+    sheerka = get_sheerka()
+    concept = get_default_concept()
+    sheerka.create_new_concept(get_context(sheerka), concept)
+
+    sheerka.cache_by_key = {}  # reset the cache
+    loaded = sheerka.get_by_id(concept.id)
+
+    assert loaded is not None
+    assert loaded == concept
+
 
 def test_i_can_get_list_of_concept_when_same_key_when_no_cache():
     sheerka = get_sheerka()
@@ -198,7 +219,7 @@ def test_i_can_get_list_of_concept_when_same_key_when_no_cache():
 
     assert res1.value.body.key == res2.value.body.key  # same key
 
-    sheerka.concepts_cache = {}  # reset the cache
+    sheerka.cache_by_key = {}  # reset the cache
 
     result = sheerka.get(concept1.key)
     assert len(result) == 2
@@ -217,7 +238,7 @@ def test_i_can_get_list_of_concept_when_same_key_when_cache():
 
     assert res1.value.body.key == res2.value.body.key  # same key
 
-    # sheerka.concepts_cache = {}  # Do not reset the cache
+    # sheerka.cache_by_key = {}  # Do not reset the cache
 
     result = sheerka.get(concept1.key)
     assert len(result) == 2
@@ -280,14 +301,25 @@ def test_i_cannot_get_when_key_is_none():
     assert res.body == "Concept key is undefined."
 
 
-def test_unknown_concept_is_return_when_the_concept_is_not_found():
+def test_unknown_concept_is_return_when_the_concept_key_is_not_found():
     sheerka = get_sheerka()
 
-    loaded = sheerka.get("concept_that_does_not_exist")
+    loaded = sheerka.get("key_that_does_not_exist")
 
     assert loaded is not None
     assert sheerka.isinstance(loaded, BuiltinConcepts.UNKNOWN_CONCEPT)
-    assert loaded.body == "concept_that_does_not_exist"
+    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():
+    sheerka = get_sheerka()
+
+    loaded = sheerka.get_by_id("id_that_does_not_exist")
+
+    assert loaded is not None
+    assert sheerka.isinstance(loaded, BuiltinConcepts.UNKNOWN_CONCEPT)
+    assert loaded.body == ("id", "id_that_does_not_exist")
     assert loaded.metadata.is_evaluated
 
 
@@ -372,7 +404,7 @@ def test_i_cannot_instantiate_an_unknown_concept():
     new = sheerka.new("fake_concept")
 
     assert sheerka.isinstance(new, BuiltinConcepts.UNKNOWN_CONCEPT)
-    assert new.body == "fake_concept"
+    assert new.body == ('key', 'fake_concept')
 
 
 def test_i_cannot_instantiate_with_invalid_id():
@@ -383,7 +415,7 @@ def test_i_cannot_instantiate_with_invalid_id():
     new = sheerka.new(("foo", "invalid_id"))
 
     assert sheerka.isinstance(new, BuiltinConcepts.UNKNOWN_CONCEPT)
-    assert new.body == "foo"
+    assert new.body == [('key', 'foo'), ('id', 'invalid_id')]
 
 
 def test_i_cannot_instantiate_with_invalid_key():
@@ -394,7 +426,7 @@ def test_i_cannot_instantiate_with_invalid_key():
     new = sheerka.new(("invalid_key", "1001"))
 
     assert sheerka.isinstance(new, BuiltinConcepts.UNKNOWN_CONCEPT)
-    assert new.body == "invalid_key"
+    assert new.body == [('key', 'invalid_key'), ('id', '1001')]
 
 
 def test_concept_id_is_irrelevant_when_only_one_concept():
@@ -457,8 +489,8 @@ def test_list_of_concept_is_sorted_by_id():
 
 
 @pytest.mark.parametrize("body, expected", [
-    (None, None),
-    ("", ""),
+    # (None, None),
+    # ("", ""),
     ("1", 1),
     ("1+1", 2),
     ("'one'", "one"),
@@ -871,3 +903,53 @@ def test_i_cannot_add_the_same_concept_twice_in_a_set():
     all_entries = sheerka.sdp.get("All_" + all_foos.id, None, False)
     assert len(all_entries) == 1
     assert foo.id in all_entries
+
+
+def test_i_get_elements_from_a_set():
+    sheerka = get_sheerka(False, False)
+
+    one = Concept("one")
+    two = Concept("two")
+    three = Concept("three")
+    number = Concept("number")
+
+    for c in [one, two, three, number]:
+        sheerka.set_id_if_needed(c, False)
+        sheerka.add_in_cache(c)
+
+    context = get_context(sheerka)
+    for c in [one, two, three]:
+        sheerka.add_concept_to_set(context, c, number)
+
+    elements = sheerka.get_set_elements(number)
+
+    assert set(elements) == set([one, two, three])
+
+
+def test_i_cannot_get_elements_if_not_a_set():
+    sheerka = get_sheerka(False, False)
+    one = Concept("one")
+    sheerka.set_id_if_needed(one, False)
+    sheerka.add_in_cache(one)
+
+    error = sheerka.get_set_elements(one)
+
+    assert sheerka.isinstance(error, BuiltinConcepts.NOT_A_SET)
+    assert error.body == one
+
+
+def test_isa_and_isa_group():
+    sheerka = get_sheerka()
+
+    group = Concept("group").init_key()
+    group.metadata.id = "1001"
+    assert not sheerka.isagroup(group)
+
+    foo = Concept("foo").init_key()
+    foo.metadata.id = "1002"
+    assert not sheerka.isa(foo, group)
+
+    context = get_context(sheerka)
+    sheerka.add_concept_to_set(context, foo, group)
+    assert sheerka.isagroup(group)
+    assert sheerka.isa(foo, group)