Extend concept type API (#254)

## What is the goal of this PR?

We catch up client-nodejs with the Java client version 2.9.0, which exposes an extended set of APIs on `Type`s.
We implement:
* `ThingType.get_owns_explicit()` and `ThingType.get_owns_overridden`
* `AttributeType.get_owners_explicit()`
* `ThingType.get_plays_explicit()`
* `ThingType.get_plays_overridden()`
* `RelationType.get_relates_explicit()` and `RelationType.get_relates_overridden()`

We also implement new behaviour test steps required to cover these APIs. 

## What are the changes implemented in this PR?

* Update `typedb-protocol` to version 2.9.0, and synchronise the naming conventions that were updated
* Implement Concept `Type` APIs that were missing, matching the requirements released in client-java 2.9.0
* Update any required changes in the lower-level packges to build requests
* update `typedb-behaviour` to latest and implement news steps required to test the new APIs  
* Disambiguate clashing behaviour steps by adding type hints to them

Author: flyingsilverfin

dependencies/vaticle/artifacts.bzl

@@ -29,7 +29,7 @@ def vaticle_typedb_artifacts():
         artifact_name = "typedb-server-{platform}-{version}.{ext}",
         tag_source = deployment["artifact.release"],
         commit_source = deployment["artifact.snapshot"],
-        commit = "0f84e6577b6ef60dac838b604e6d66222c512957",
+        tag = "2.9.0",
     )
 
 def vaticle_typedb_cluster_artifacts():
@@ -39,5 +39,5 @@ def vaticle_typedb_cluster_artifacts():
         artifact_name = "typedb-cluster-all-{platform}-{version}.{ext}",
         tag_source = deployment_private["artifact.release"],
         commit_source = deployment_private["artifact.snapshot"],
-        commit = "aa8531f154d7c74c8922c71a252022c650c1be0c"
+        tag = "2.9.0",
     )

dependencies/vaticle/repositories.bzl

@@ -32,12 +32,12 @@ def vaticle_typedb_common():
     git_repository(
         name = "vaticle_typedb_common",
         remote = "https://github.com/vaticle/typedb-common",
-        commit = "d11cee9745e4559450ef4ccb140d4e9781587932" # sync-marker: do not remove this comment, this is used for sync-dependencies by @vaticle_typedb_common
+        tag = "2.9.0" # sync-marker: do not remove this comment, this is used for sync-dependencies by @vaticle_typedb_common
     )
 
 def vaticle_typedb_behaviour():
     git_repository(
         name = "vaticle_typedb_behaviour",
         remote = "https://github.com/vaticle/typedb-behaviour",
-        commit = "7aa405c01eb46b8a28867bc49c4f8c0427c32d52", # sync-marker: do not remove this comment, this is used for sync-dependencies by @vaticle_typedb_behaviour
+        commit = "6e462bcbef73c75405264777069a22bca696a644" # sync-marker: do not remove this comment, this is used for sync-dependencies by @vaticle_typedb_behaviour
     )

requirements.txt

@@ -32,6 +32,6 @@
 ## Dependencies
 
 # IMPORTANT: Any changes to these dependencies should be copied to requirements_dev.txt.
-typedb-protocol==2.6.0
+typedb-protocol==2.9.0
 grpcio==1.43.0
 protobuf==3.15.5

requirements_dev.txt

@@ -30,7 +30,7 @@
 
 ## Dependencies
 
-typedb-protocol==2.6.0
+typedb-protocol==2.9.0
 grpcio==1.43.0
 protobuf==3.15.5
 

tests/behaviour/concept/type/attributetype/attribute_type_steps.py

@@ -34,12 +34,14 @@ def step_impl(context: Context, type_label: str, value_type: str):
 
 @step("attribute({type_label}) get value type: {value_type}")
 def step_impl(context: Context, type_label: str, value_type: str):
-    assert_that(context.tx().concepts().get_attribute_type(type_label).get_value_type(), is_(parse_value_type(value_type)))
+    assert_that(context.tx().concepts().get_attribute_type(type_label).get_value_type(),
+                is_(parse_value_type(value_type)))
 
 
 @step("attribute({type_label}) get supertype value type: {value_type}")
 def step_impl(context: Context, type_label: str, value_type: str):
-    supertype = context.tx().concepts().get_attribute_type(type_label).as_remote(context.tx()).get_supertype().as_attribute_type()
+    supertype = context.tx().concepts().get_attribute_type(type_label).as_remote(
+        context.tx()).get_supertype().as_attribute_type()
     assert_that(supertype.get_value_type(), is_(parse_value_type(value_type)))
 
 
@@ -129,6 +131,26 @@ def step_impl(context: Context, type_label: str):
         assert_that(actuals, not_(has_item(owner_label)))
 
 
+@step("attribute({type_label}) get key owners explicit contain")
+def step_impl(context: Context, type_label: str):
+    owner_labels = [parse_label(s) for s in parse_list(context.table)]
+    attribute_type = context.tx().concepts().get_attribute_type(type_label)
+    actuals = list(
+        map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=True)))
+    for owner_label in owner_labels:
+        assert_that(actuals, has_item(owner_label))
+
+
+@step("attribute({type_label}) get key owners explicit do not contain")
+def step_impl(context: Context, type_label: str):
+    owner_labels = [parse_label(s) for s in parse_list(context.table)]
+    attribute_type = context.tx().concepts().get_attribute_type(type_label)
+    actuals = list(
+        map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=True)))
+    for owner_label in owner_labels:
+        assert_that(actuals, not_(has_item(owner_label)))
+
+
 @step("attribute({type_label}) get attribute owners contain")
 def step_impl(context: Context, type_label: str):
     owner_labels = [parse_label(s) for s in parse_list(context.table)]
@@ -145,3 +167,21 @@ def step_impl(context: Context, type_label: str):
     actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners(only_key=False)))
     for owner_label in owner_labels:
         assert_that(actuals, not_(has_item(owner_label)))
+
+
+@step("attribute({type_label}) get attribute owners explicit contain")
+def step_impl(context: Context, type_label: str):
+    owner_labels = [parse_label(s) for s in parse_list(context.table)]
+    attribute_type = context.tx().concepts().get_attribute_type(type_label)
+    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=False)))
+    for owner_label in owner_labels:
+        assert_that(actuals, has_item(owner_label))
+
+
+@step("attribute({type_label}) get attribute owners explicit do not contain")
+def step_impl(context: Context, type_label: str):
+    owner_labels = [parse_label(s) for s in parse_list(context.table)]
+    attribute_type = context.tx().concepts().get_attribute_type(type_label)
+    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=False)))
+    for owner_label in owner_labels:
+        assert_that(actuals, not_(has_item(owner_label)))

tests/behaviour/concept/type/relationtype/relation_type_steps.py

@@ -80,6 +80,12 @@ def step_impl(context: Context, relation_label: str, role_label: str, is_null):
     assert_that(context.tx().concepts().get_relation_type(relation_label).as_remote(context.tx()).get_relates(role_label) is None, is_(is_null))
 
 
+@step("relation({relation_label}) get overridden role({role_label}) is null: {is_null}")
+def step_impl(context: Context, relation_label: str, role_label: str, is_null):
+    is_null = parse_bool(is_null)
+    assert_that(context.tx().concepts().get_relation_type(relation_label).as_remote(context.tx()).get_relates_overridden(role_label) is None, is_(is_null))
+
+
 @step("relation({relation_label}) get role({role_label}) set label: {new_label}")
 def step_impl(context: Context, relation_label: str, role_label: str, new_label: str):
     context.tx().concepts().get_relation_type(relation_label).as_remote(context.tx()).get_relates(role_label).as_remote(context.tx()).set_label(new_label)
@@ -90,6 +96,11 @@ def step_impl(context: Context, relation_label: str, role_label: str, get_label:
     assert_that(context.tx().concepts().get_relation_type(relation_label).as_remote(context.tx()).get_relates(role_label).as_remote(context.tx()).get_label().name(), is_(get_label))
 
 
+@step("relation({relation_label}) get overridden role({role_label}) get label: {get_label}")
+def step_impl(context: Context, relation_label: str, role_label: str, get_label: str):
+    assert_that(context.tx().concepts().get_relation_type(relation_label).as_remote(context.tx()).get_relates_overridden(role_label).as_remote(context.tx()).get_label().name(), is_(get_label))
+
+
 @step("relation({relation_label}) get role({role_label}) is abstract: {is_abstract}")
 def step_impl(context: Context, relation_label: str, role_label: str, is_abstract):
     is_abstract = parse_bool(is_abstract)
@@ -116,6 +127,26 @@ def step_impl(context: Context, relation_label: str):
         assert_that(actuals, not_(has_item(role_label)))
 
 
+def get_actual_related_role_explicit_labels(context: Context, relation_label: str):
+    return [r.get_label() for r in context.tx().concepts().get_relation_type(relation_label).as_remote(context.tx()).get_relates_explicit()]
+
+
+@step("relation({relation_label}) get related explicit roles contain")
+def step_impl(context: Context, relation_label: str):
+    role_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_related_role_explicit_labels(context, relation_label)
+    for role_label in role_labels:
+        assert_that(actuals, has_item(role_label))
+
+
+@step("relation({relation_label}) get related explicit roles do not contain")
+def step_impl(context: Context, relation_label: str):
+    role_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_related_role_explicit_labels(context, relation_label)
+    for role_label in role_labels:
+        assert_that(actuals, not_(has_item(role_label)))
+
+
 @step("relation({relation_label}) get role({role_label}) get supertype: {super_label:ScopedLabel}")
 def step_impl(context: Context, relation_label: str, role_label: str, super_label: Label):
     supertype = context.tx().concepts().get_relation_type(super_label.scope()).as_remote(context.tx()).get_relates(super_label.name())

tests/behaviour/concept/type/thingtype/thing_type_steps.py

@@ -22,9 +22,9 @@
 from behave import *
 from hamcrest import *
 
-from typedb.client import *
 from tests.behaviour.config.parameters import parse_bool, parse_list, RootLabel, parse_label
 from tests.behaviour.context import Context
+from typedb.client import *
 
 
 @step("put {root_label:RootLabel} type: {type_label}")
@@ -51,20 +51,20 @@ def step_impl(context: Context, root_label: RootLabel, type_label: str):
     context.get_thing_type(root_label, type_label).as_remote(context.tx()).delete()
 
 
-@step("{root_label:RootLabel}({type_label}) is null: {is_null}")
-def step_impl(context: Context, root_label: RootLabel, type_label: str, is_null):
+@step("{root_label:RootLabel}({type_label:Label}) is null: {is_null}")
+def step_impl(context: Context, root_label: RootLabel, type_label: Label, is_null):
     is_null = parse_bool(is_null)
-    assert_that(context.get_thing_type(root_label, type_label) is None, is_(is_null))
+    assert_that(context.get_thing_type(root_label, type_label.name()) is None, is_(is_null))
 
 
 @step("{root_label:RootLabel}({type_label}) set label: {new_label}")
 def step_impl(context: Context, root_label: RootLabel, type_label: str, new_label: str):
     context.get_thing_type(root_label, type_label).as_remote(context.tx()).set_label(new_label)
 
 
-@step("{root_label:RootLabel}({type_label}) get label: {get_label}")
-def step_impl(context: Context, root_label: RootLabel, type_label: str, get_label: str):
-    assert_that(context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_label().name(), is_(get_label))
+@step("{root_label:RootLabel}({type_label:Label}) get label: {get_label}")
+def step_impl(context: Context, root_label: RootLabel, type_label: Label, get_label: str):
+    assert_that(context.get_thing_type(root_label, type_label.name()).as_remote(context.tx()).get_label().name(), is_(get_label))
 
 
 @step("{root_label:RootLabel}({type_label}) set abstract: {is_abstract}; throws exception")
@@ -229,18 +229,42 @@ def step_impl(context: Context, root_label: RootLabel, type_label: str, att_type
     context.get_thing_type(root_label, type_label).as_remote(context.tx()).unset_owns(attribute_type)
 
 
+def get_actual_owns_key_types(context: Context, root_label: RootLabel, type_label: str):
+    return [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns(keys_only=True)]
+
+
 @step("{root_label:RootLabel}({type_label}) get owns key types contain")
 def step_impl(context: Context, root_label: RootLabel, type_label: str):
     attribute_labels = [parse_label(s) for s in parse_list(context.table)]
-    actuals = [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns(keys_only=True)]
+    actuals = get_actual_owns_key_types(context, root_label, type_label)
     for attribute_label in attribute_labels:
         assert_that(actuals, has_item(attribute_label))
 
 
 @step("{root_label:RootLabel}({type_label}) get owns key types do not contain")
 def step_impl(context: Context, root_label: RootLabel, type_label: str):
     attribute_labels = [parse_label(s) for s in parse_list(context.table)]
-    actuals = [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns(keys_only=True)]
+    actuals = get_actual_owns_key_types(context, root_label, type_label)
+    for attribute_label in attribute_labels:
+        assert_that(actuals, not_(has_item(attribute_label)))
+
+
+def get_actual_owns_explicit_key_types(context: Context, root_label: RootLabel, type_label: str):
+    return [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns_explicit(keys_only=True)]
+
+
+@step("{root_label:RootLabel}({type_label}) get owns explicit key types contain")
+def step_impl(context: Context, root_label: RootLabel, type_label: str):
+    attribute_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_owns_explicit_key_types(context, root_label, type_label)
+    for attribute_label in attribute_labels:
+        assert_that(actuals, has_item(attribute_label))
+
+
+@step("{root_label:RootLabel}({type_label}) get owns explicit key types do not contain")
+def step_impl(context: Context, root_label: RootLabel, type_label: str):
+    attribute_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_owns_explicit_key_types(context, root_label, type_label)
     for attribute_label in attribute_labels:
         assert_that(actuals, not_(has_item(attribute_label)))
 
@@ -279,22 +303,59 @@ def step_impl(context: Context, root_label: RootLabel, type_label: str, att_type
     context.get_thing_type(root_label, type_label).as_remote(context.tx()).set_owns(attribute_type)
 
 
+def get_actual_owns(context: Context, root_label: RootLabel, type_label: str):
+    return [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns()]
+
+
 @step("{root_label:RootLabel}({type_label}) get owns attribute types contain")
 def step_impl(context: Context, root_label: RootLabel, type_label: str):
     attribute_labels = [parse_label(s) for s in parse_list(context.table)]
-    actuals = [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns()]
+    actuals = get_actual_owns(context, root_label, type_label)
     for attribute_label in attribute_labels:
         assert_that(actuals, has_item(attribute_label))
 
 
 @step("{root_label:RootLabel}({type_label}) get owns attribute types do not contain")
 def step_impl(context: Context, root_label: RootLabel, type_label: str):
     attribute_labels = [parse_label(s) for s in parse_list(context.table)]
-    actuals = [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns()]
+    actuals = get_actual_owns(context, root_label, type_label)
     for attribute_label in attribute_labels:
         assert_that(actuals, not_(has_item(attribute_label)))
 
 
+def get_actual_owns_explicit(context: Context, root_label: RootLabel, type_label: str):
+    return [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_owns_explicit()]
+
+
+@step("{root_label:RootLabel}({type_label}) get owns explicit attribute types contain")
+def step_impl(context: Context, root_label: RootLabel, type_label: str):
+    attribute_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_owns_explicit(context, root_label, type_label)
+    for attribute_label in attribute_labels:
+        assert_that(actuals, has_item(attribute_label))
+
+
+@step("{root_label:RootLabel}({type_label}) get owns explicit attribute types do not contain")
+def step_impl(context: Context, root_label: RootLabel, type_label: str):
+    attribute_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_owns_explicit(context, root_label, type_label)
+    for attribute_label in attribute_labels:
+        assert_that(actuals, not_(has_item(attribute_label)))
+
+
+@step("{root_label:RootLabel}({type_label:Label}) get owns overridden attribute({attr_type_label}) is null: {is_null}")
+def step_impl(context: Context, root_label: RootLabel, type_label: Label, attr_type_label: str, is_null):
+    is_null = parse_bool(is_null)
+    attribute_type = context.tx().concepts().get_attribute_type(attr_type_label)
+    assert_that(context.get_thing_type(root_label, type_label.name()).as_remote(context.tx()).get_owns_overridden(attribute_type) is None, is_(is_null))
+
+
+@step("{root_label:RootLabel}({type_label:Label}) get owns overridden attribute({attr_type_label}) get label: {label}")
+def step_impl(context: Context, root_label: RootLabel, type_label: Label, attr_type_label: str, label: str):
+    attribute_type = context.tx().concepts().get_attribute_type(attr_type_label)
+    assert_that(context.get_thing_type(root_label, type_label.name()).as_remote(context.tx()).get_owns_overridden(attribute_type).get_label().name(), is_(label))
+
+
 @step("{root_label:RootLabel}({type_label}) set plays role: {role_label:ScopedLabel} as {overridden_label:ScopedLabel}; throws exception")
 def step_impl(context: Context, root_label: RootLabel, type_label: str, role_label: Label, overridden_label: Label):
     role_type = context.tx().concepts().get_relation_type(role_label.scope()).as_remote(context.tx()).get_relates(role_label.name())
@@ -345,18 +406,42 @@ def step_impl(context: Context, root_label: RootLabel, type_label: str, role_lab
     context.get_thing_type(root_label, type_label).as_remote(context.tx()).unset_plays(role_type)
 
 
+def get_actual_plays(context: Context, root_label: RootLabel, type_label: str):
+    return [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_plays()]
+
+
 @step("{root_label:RootLabel}({type_label}) get playing roles contain")
 def step_impl(context: Context, root_label: RootLabel, type_label: str):
     role_labels = [parse_label(s) for s in parse_list(context.table)]
-    actuals = [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_plays()]
+    actuals = get_actual_plays(context, root_label, type_label)
     for role_label in role_labels:
         assert_that(role_label, is_in(actuals))
 
 
 @step("{root_label:RootLabel}({type_label}) get playing roles do not contain")
 def step_impl(context: Context, root_label: RootLabel, type_label: str):
     role_labels = [parse_label(s) for s in parse_list(context.table)]
-    actuals = [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_plays()]
+    actuals = get_actual_plays(context, root_label, type_label)
+    for role_label in role_labels:
+        assert_that(role_label, not_(is_in(actuals)))
+
+
+def get_actual_plays_explicit(context: Context, root_label: RootLabel, type_label: str):
+    return [t.get_label() for t in context.get_thing_type(root_label, type_label).as_remote(context.tx()).get_plays_explicit()]
+
+
+@step("{root_label:RootLabel}({type_label}) get playing roles explicit contain")
+def step_impl(context: Context, root_label: RootLabel, type_label: str):
+    role_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_plays_explicit(context, root_label, type_label)
+    for role_label in role_labels:
+        assert_that(role_label, is_in(actuals))
+
+
+@step("{root_label:RootLabel}({type_label}) get playing roles explicit do not contain")
+def step_impl(context: Context, root_label: RootLabel, type_label: str):
+    role_labels = [parse_label(s) for s in parse_list(context.table)]
+    actuals = get_actual_plays_explicit(context, root_label, type_label)
     for role_label in role_labels:
         assert_that(role_label, not_(is_in(actuals)))