Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/conftest.py

@@ -0,0 +1,93 @@
+from typing import (
+    Union,
+    Sequence,
+    Any,
+    ContextManager,
+    Protocol,
+    Iterator,
+)
+
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from _pytest.fixtures import SubRequest
+from contextlib import contextmanager
+
+from weaviate import WeaviateClient
+from weaviate.rbac.models import PermissionsCreateType
+
+
+def _sanitize_role_name(name: str) -> str:
+    return (
+        name.replace("[", "")
+        .replace("]", "")
+        .replace("-", "")
+        .replace(" ", "")
+        .replace(".", "")
+        .replace("{", "")
+        .replace("}", "")
+    )
+
+
+def generate_missing_permissions(permissions: list):
+    result = []
+    for i in range(len(permissions)):
+        result.append(permissions[:i] + permissions[i + 1 :])
+    return result
+
+
+class RoleWrapperProtocol(Protocol):
+    def __call__(
+        self,
+        admin_client: WeaviateClient,
+        request: SubRequest,
+        permissions: PermissionsCreateType,
+        user: str = "custom-user",
+    ) -> ContextManager[Any]: ...
+
+
+@pytest.fixture
+def role_wrapper() -> RoleWrapperProtocol:
+    def wrapper(
+        admin_client: WeaviateClient,
+        request: SubRequest,
+        permissions: PermissionsCreateType,
+        user: str = "custom-user",
+    ) -> Iterator[None]:
+        name = _sanitize_role_name(request.node.name) + "role"
+        admin_client.roles.delete(name)
+        if not isinstance(permissions, list) or len(permissions) > 0:
+            admin_client.roles.create(role_name=name, permissions=permissions)
+            admin_client.users.assign_roles(user_id=user, role_names=name)
+
+        yield
+
+        if not isinstance(permissions, list) or len(permissions) > 0:
+            admin_client.users.revoke_roles(user_id=user, role_names=name)
+            admin_client.roles.delete(name)
+
+    return contextmanager(wrapper)
+
+
+@pytest.fixture
+def admin_client():
+    with weaviate.connect_to_local(
+        port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key("admin-key")
+    ) as client:
+        yield client
+
+
+@pytest.fixture
+def custom_client():
+    with weaviate.connect_to_local(
+        port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key("custom-key")
+    ) as client:
+        yield client
+
+
+@pytest.fixture
+def viewer_client():
+    with weaviate.connect_to_local(
+        port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key("viewer-key")
+    ) as client:
+        yield client

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_batch_grpc.py

@@ -0,0 +1,49 @@
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from typing_extensions import Optional
+from weaviate.rbac.models import Permissions
+from _pytest.fixtures import SubRequest
+from .conftest import _sanitize_role_name, generate_missing_permissions, RoleWrapperProtocol
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_batch_grpc(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete([name + "1", name + "2"])
+
+    col1 = admin_client.collections.create(
+        name=name + "1", multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    col2 = admin_client.collections.create(
+        name=name + "2", multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    tenant: Optional[str] = None
+    if mt:
+        tenant = "tenant1"
+        col1.tenants.create(tenant)
+        col2.tenants.create(tenant)
+    admin_client.roles.delete(name)
+
+    required_permissions = [
+        Permissions.data(collection=col1.name, create=True, update=True),
+        Permissions.data(collection=col2.name, create=True, update=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        with custom_client.batch.fixed_size() as batch:
+            batch.add_object(collection=col1.name, properties={}, tenant=tenant)
+            batch.add_object(collection=col2.name, properties={}, tenant=tenant)
+        assert len(custom_client.batch.failed_objects) == 0
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            with custom_client.batch.fixed_size() as batch:
+                batch.add_object(collection=col1.name, properties={}, tenant=tenant)
+                batch.add_object(collection=col2.name, properties={}, tenant=tenant)
+            # only one permission is missing, so one object will fail
+            assert len(custom_client.batch.failed_objects) == 1
+    admin_client.collections.delete([name + "1", name + "2"])

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_casing.py

@@ -0,0 +1,61 @@
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from weaviate.rbac.models import Permissions
+
+from .conftest import _sanitize_role_name
+from _pytest.fixtures import SubRequest
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+@pytest.mark.parametrize("to_upper", [True, False])
+def test_rbac_refs(request: SubRequest, admin_client, custom_client, to_upper: bool):
+    name = _sanitize_role_name(request.node.name)
+    if to_upper:
+        name = name[0].upper() + name[1:]
+    admin_client.collections.delete(name)
+    admin_client.roles.delete(name)
+    collection = admin_client.collections.create(name=name)
+
+    admin_client.roles.create(
+        role_name=name,
+        permissions=[
+            Permissions.collections(collection=name, read_config=True),
+            Permissions.data(collection=name, read=True),
+        ],
+    )
+    admin_client.users.assign_roles(user_id="custom-user", role_names=name)
+    collection_no_rights = custom_client.collections.get(collection.name)
+    collection_no_rights.query.fetch_objects()
+
+    admin_client.users.revoke_roles(user_id="custom-user", role_names=name)
+    admin_client.roles.delete(name)
+
+    admin_client.collections.delete(name)
+
+
+def test_role_name_case_sensitivity(request: SubRequest, admin_client):
+    col_name = _sanitize_role_name(request.node.name)
+    l_name = _sanitize_role_name(request.node.name)
+    u_name = l_name[0].upper() + l_name[1:]
+
+    admin_client.collections.delete(col_name)
+    admin_client.roles.delete(l_name)
+    admin_client.roles.delete(u_name)
+
+    admin_client.roles.create(
+        role_name=l_name, permissions=Permissions.collections(collection="lower", read_config=True)
+    )
+
+    admin_client.roles.create(
+        role_name=u_name, permissions=Permissions.collections(collection="upper", read_config=True)
+    )
+
+    admin_client.users.assign_roles(user_id="custom-user", role_names=[l_name, u_name])
+
+    roles = admin_client.users.get_assigned_roles("custom-user")
+    assert sorted(roles.keys()) == sorted([l_name, u_name])
+
+    admin_client.roles.delete(l_name)
+    admin_client.roles.delete(u_name)

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_db_users.py

@@ -0,0 +1,157 @@
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from weaviate.exceptions import UnexpectedStatusCodeError
+from weaviate.rbac.models import Permissions
+from _pytest.fixtures import SubRequest
+from .conftest import _sanitize_role_name
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+def test_db_user_create_collection(request: SubRequest, admin_client):
+    admin_client.users.db.delete(user_id="test-user")
+    api_key = admin_client.users.db.create(user_id="test-user")
+
+    admin_client.users.db.assign_roles(user_id="test-user", role_names="admin")
+
+    collection_name = _sanitize_role_name(request.node.name) + "col"
+
+    # normal collection
+    with weaviate.connect_to_local(
+        port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key(api_key)
+    ) as custom_client:
+        admin_client.collections.delete(collection_name)
+
+        collection = custom_client.collections.create(
+            collection_name,
+            properties=[wvc.config.Property(name="name", data_type=wvc.config.DataType.TEXT)],
+        )
+        uuid1 = collection.data.insert({"name": "testing"})
+
+        obj = collection.query.fetch_object_by_id(uuid1)
+        assert obj.properties["name"] == "testing"
+
+        assert collection.data.delete_by_id(uuid1)
+        assert collection.query.fetch_object_by_id(uuid1) is None
+
+        custom_client.collections.delete(collection_name)
+        assert not custom_client.collections.exists(collection_name)
+    admin_client.users.db.delete(user_id="test-user")
+
+
+def test_db_user_multi_tenant(request: SubRequest, admin_client):
+    admin_client.users.db.delete(user_id="test-user")
+    api_key = admin_client.users.db.create(user_id="test-user")
+
+    admin_client.users.db.assign_roles(user_id="test-user", role_names="admin")
+
+    collection_name = _sanitize_role_name(request.node.name) + "col"
+    with weaviate.connect_to_local(
+        port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key(api_key)
+    ) as custom_client:
+        admin_client.collections.delete(collection_name)
+
+        collection = custom_client.collections.create(
+            collection_name,
+            properties=[wvc.config.Property(name="name", data_type=wvc.config.DataType.TEXT)],
+            multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=True),
+        )
+
+        collection.tenants.create(["tenant1", "tenant2", "tenant3"])
+        collection = collection.with_tenant("tenant1")
+
+        uuid1 = collection.data.insert({"name": "testing"})
+
+        obj = collection.query.fetch_object_by_id(uuid1)
+        assert obj.properties["name"] == "testing"
+
+        assert collection.data.delete_by_id(uuid1)
+        assert collection.query.fetch_object_by_id(uuid1) is None
+
+        # update tenant status to inactive and fail
+        collection.tenants.update(
+            wvc.tenants.TenantUpdate(
+                name="tenant2", activity_status=wvc.tenants.TenantUpdateActivityStatus.INACTIVE
+            )
+        )
+        collection = collection.with_tenant("tenant2")
+        with pytest.raises(UnexpectedStatusCodeError):
+            collection.data.insert({"name": "testing"})
+
+        custom_client.collections.delete(collection_name)
+        assert not custom_client.collections.exists(collection_name)
+    admin_client.users.db.delete(user_id="test-user")
+
+
+def test_db_user_role_and_users(request: SubRequest, admin_client):
+    admin_client.users.db.delete(user_id="test-user")
+    admin_client.users.db.delete(user_id="second-user")
+    api_key = admin_client.users.db.create(user_id="test-user")
+
+    admin_client.users.db.assign_roles(user_id="test-user", role_names="admin")
+
+    collection_name = _sanitize_role_name(request.node.name) + "col"
+    role_name = _sanitize_role_name(request.node.name) + "role"
+    with weaviate.connect_to_local(
+        port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key(api_key)
+    ) as custom_client:
+        admin_client.collections.delete(collection_name)
+        admin_client.roles.delete(role_name)
+        custom_client.roles.create(
+            role_name=role_name,
+            permissions=[
+                Permissions.data(collection=collection_name, read=True, create=True),
+                Permissions.collections(collection=collection_name, create_collection=True),
+            ],
+        )
+
+        second_api_key = custom_client.users.db.create(user_id="second-user")
+        with weaviate.connect_to_local(
+            port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key(second_api_key)
+        ) as second_client:
+            # cannot create collection without permissions
+            with pytest.raises(UnexpectedStatusCodeError):
+                second_client.collections.create(collection_name)
+
+            custom_client.users.db.assign_roles(user_id="second-user", role_names=role_name)
+            second_client.collections.create(collection_name)
+    admin_client.users.db.delete(user_id="test-user")
+    admin_client.users.db.delete(user_id="second-user")
+    admin_client.collections.delete(collection_name)
+
+
+def test_db_user_batch_import(request: SubRequest, admin_client):
+    admin_client.users.db.delete(user_id="test-user")
+    api_key = admin_client.users.db.create(user_id="test-user")
+
+    admin_client.users.db.assign_roles(user_id="test-user", role_names="admin")
+
+    collection_name = _sanitize_role_name(request.node.name) + "col"
+    with weaviate.connect_to_local(
+        port=8081, grpc_port=50052, auth_credentials=wvc.init.Auth.api_key(api_key)
+    ) as custom_client:
+        admin_client.collections.delete(collection_name)
+        collection = custom_client.collections.create(
+            collection_name,
+            properties=[
+                wvc.config.Property(name="name", data_type=wvc.config.DataType.TEXT),
+                wvc.config.Property(name="counter", data_type=wvc.config.DataType.INT),
+            ],
+        )
+        num_objects = 100
+        ret = collection.data.insert_many(
+            [{"name": "test" + str(i), "counter": i} for i in range(num_objects)]
+        )
+        assert len(collection) == num_objects
+        uuid_to_check = ret.uuids[25]
+        obj = collection.query.fetch_object_by_id(uuid_to_check)
+        assert obj.properties["name"] == "test" + str(25)
+
+        assert collection.data.delete_by_id(uuid_to_check)
+        assert collection.query.fetch_object_by_id(uuid_to_check) is None
+        assert len(collection) == num_objects - 1
+
+        custom_client.collections.delete(collection_name)
+        assert not custom_client.collections.exists(collection_name)
+    admin_client.users.db.delete(user_id="test-user")

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_object_endpoint.py

@@ -0,0 +1,353 @@
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from weaviate.rbac.models import Permissions
+from _pytest.fixtures import SubRequest
+from .conftest import _sanitize_role_name, RoleWrapperProtocol, generate_missing_permissions
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_insert(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete(name)
+    admin_client.roles.delete(name)
+    col = admin_client.collections.create(
+        name=name, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    if mt:
+        col.tenants.create("tenant1")
+
+    required_permissions = [
+        Permissions.data(collection=col.name, create=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(name)  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        source_no_rights.data.insert({})
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.insert({})
+            assert e.value.status_code == 403
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_insert_ref(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete([name + "source", name + "target"])
+    admin_client.roles.delete(name)
+    target = admin_client.collections.create(
+        name=name + "target", multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    source = admin_client.collections.create(
+        name=name + "source",
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+        references=[wvc.config.ReferenceProperty(name="ref", target_collection=target.name)],
+    )
+
+    if mt:
+        source.tenants.create("tenant1")
+        target.tenants.create("tenant1")
+        target = target.with_tenant("tenant1")
+
+    uuid_target = target.data.insert({})
+
+    required_permissions = [
+        Permissions.data(collection=source.name, create=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(
+            source.name
+        )  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        source_no_rights.data.insert(properties={}, references={"ref": uuid_target})
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                source.name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.insert(properties={}, references={"ref": uuid_target})
+            assert e.value.status_code == 403
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_replace(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete(name)
+    admin_client.roles.delete(name)
+    col = admin_client.collections.create(
+        name=name, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    if mt:
+        col.tenants.create("tenant1")
+        col = col.with_tenant("tenant1")
+
+    uuid_to_replace = col.data.insert({})
+
+    required_permissions = [
+        Permissions.data(collection=col.name, update=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(name)  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        source_no_rights.data.replace(uuid=uuid_to_replace, properties={})
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.replace(uuid=uuid_to_replace, properties={})
+            assert e.value.status_code == 403
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_replace_ref(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete([name + "source", name + "target"])
+    admin_client.roles.delete(name)
+    target = admin_client.collections.create(
+        name=name + "target", multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    source = admin_client.collections.create(
+        name=name + "source",
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+        references=[wvc.config.ReferenceProperty(name="ref", target_collection=target.name)],
+    )
+
+    if mt:
+        source.tenants.create("tenant1")
+        target.tenants.create("tenant1")
+        source = source.with_tenant("tenant1")
+        target = target.with_tenant("tenant1")
+
+    uuid_target = target.data.insert({})
+    uuid_to_replace = source.data.insert({})
+
+    required_permissions = [
+        Permissions.data(collection=source.name, update=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(
+            source.name
+        )  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        source_no_rights.data.replace(
+            uuid=uuid_to_replace, properties={}, references={"ref": uuid_target}
+        )
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                source.name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.replace(
+                    uuid=uuid_to_replace, properties={}, references={"ref": uuid_target}
+                )
+            assert e.value.status_code == 403
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_update(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete(name)
+    admin_client.roles.delete(name)
+    col = admin_client.collections.create(
+        name=name, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    if mt:
+        col.tenants.create("tenant1")
+        col = col.with_tenant("tenant1")
+
+    uuid_to_replace = col.data.insert({})
+
+    required_permissions = [
+        Permissions.data(collection=col.name, update=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(name)  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        source_no_rights.data.update(uuid=uuid_to_replace, properties={})
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.update(uuid=uuid_to_replace, properties={})
+            assert e.value.status_code == 403
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_update_ref(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete([name + "source", name + "target"])
+    admin_client.roles.delete(name)
+    target = admin_client.collections.create(
+        name=name + "target", multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    source = admin_client.collections.create(
+        name=name + "source",
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+        references=[wvc.config.ReferenceProperty(name="ref", target_collection=target.name)],
+    )
+
+    if mt:
+        source.tenants.create("tenant1")
+        target.tenants.create("tenant1")
+        source = source.with_tenant("tenant1")
+        target = target.with_tenant("tenant1")
+
+    uuid_target = target.data.insert({})
+    uuid_to_replace = source.data.insert({})
+
+    required_permissions = [
+        Permissions.data(collection=source.name, update=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(
+            source.name
+        )  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        source_no_rights.data.update(
+            uuid=uuid_to_replace, properties={}, references={"ref": uuid_target}
+        )
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                source.name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.update(
+                    uuid=uuid_to_replace, properties={}, references={"ref": uuid_target}
+                )
+            assert e.value.status_code == 403
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_delete(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete(name)
+    admin_client.roles.delete(name)
+    col = admin_client.collections.create(
+        name=name, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    if mt:
+        col.tenants.create("tenant1")
+        col = col.with_tenant("tenant1")
+
+    uuid_to_delete = col.data.insert({})
+
+    required_permissions = [
+        Permissions.data(collection=col.name, delete=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        col_no_rights = custom_client.collections.get(name)  # no network call => no RBAC check
+        if mt:
+            col_no_rights = col_no_rights.with_tenant("tenant1")
+        assert len(col) == 1
+        col_no_rights.data.delete_by_id(uuid=uuid_to_delete)
+        assert len(col) == 0
+
+    uuid_to_delete = col.data.insert({})
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            col_no_rights = custom_client.collections.get(name)  # no network call => no RBAC check
+            if mt:
+                col_no_rights = col_no_rights.with_tenant("tenant1")
+
+            assert len(col) == 1
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                col_no_rights.data.delete_by_id(uuid=uuid_to_delete)
+            assert e.value.status_code == 403
+            assert len(col) == 1
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_obj_exists(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete(name)
+    admin_client.roles.delete(name)
+    col = admin_client.collections.create(
+        name=name, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    if mt:
+        col.tenants.create("tenant1")
+        col = col.with_tenant("tenant1")
+
+    uuid_to_check = col.data.insert({})
+
+    required_permissions = [
+        Permissions.data(collection=col.name, read=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        col_no_rights = custom_client.collections.get(name)  # no network call => no RBAC check
+        if mt:
+            col_no_rights = col_no_rights.with_tenant("tenant1")
+        assert col_no_rights.data.exists(uuid=uuid_to_check)
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+
+            col_no_rights = custom_client.collections.get(name)  # no network call => no RBAC check
+            if mt:
+                col_no_rights = col_no_rights.with_tenant("tenant1")
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                col_no_rights.data.exists(uuid=uuid_to_check)
+            assert e.value.status_code == 403
+    admin_client.collections.delete(name)

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_rbac_refs.py

@@ -0,0 +1,425 @@
+import uuid
+
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from _pytest.fixtures import SubRequest
+from weaviate.collections.classes.data import DataReference
+from weaviate.rbac.models import Permissions
+from weaviate.rbac.roles import _flatten_permissions
+
+from .conftest import _sanitize_role_name, generate_missing_permissions, RoleWrapperProtocol
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_rbac_refs(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    col_name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete([col_name + "target", col_name + "source"])
+    # create two collections with some objects to test refs
+    target = admin_client.collections.create(
+        name=col_name + "target",
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    source = admin_client.collections.create(
+        name=col_name + "source",
+        references=[wvc.config.ReferenceProperty(name="ref", target_collection=target.name)],
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    if mt:
+        target.tenants.create("tenant1")
+        source.tenants.create("tenant1")
+        target = target.with_tenant("tenant1")
+        source = source.with_tenant("tenant1")
+
+    uuid_target1 = target.data.insert({})
+    uuid_target2 = target.data.insert({})
+    uuid_source = source.data.insert(properties={})
+    role_name = _sanitize_role_name(request.node.name)
+    admin_client.roles.delete(role_name)
+
+    required_permissions = [
+        Permissions.collections(collection=[source.name, target.name], read_config=True),
+        Permissions.data(collection=[source.name, target.name], update=True, read=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(
+            source.name
+        )  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+
+        source_no_rights.data.reference_add(
+            from_uuid=uuid_source,
+            from_property="ref",
+            to=uuid_target1,
+        )
+
+        source_no_rights.data.reference_replace(
+            from_uuid=uuid_source,
+            from_property="ref",
+            to=uuid_target2,
+        )
+
+        source_no_rights.data.reference_delete(
+            from_uuid=uuid_source,
+            from_property="ref",
+            to=uuid_target2,
+        )
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                source.name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.reference_add(
+                    from_uuid=uuid_source,
+                    from_property="ref",
+                    to=uuid_target1,
+                )
+            assert e.value.status_code == 403
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.reference_replace(
+                    from_uuid=uuid_source,
+                    from_property="ref",
+                    to=uuid_target2,
+                )
+            assert e.value.status_code == 403
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.reference_delete(
+                    from_uuid=uuid_source,
+                    from_property="ref",
+                    to=uuid_target1,
+                )
+            assert e.value.status_code == 403
+
+    admin_client.collections.delete([target.name, source.name])
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_batch_delete_with_filter(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+) -> None:
+    col_name = _sanitize_role_name(request.node.name)
+
+    admin_client.collections.delete([col_name + "target", col_name + "source"])
+    # create two collections with some objects to test refs
+    target = admin_client.collections.create(
+        name=col_name + "target",
+        properties=[wvc.config.Property(name="prop", data_type=wvc.config.DataType.TEXT)],
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    source = admin_client.collections.create(
+        name=col_name + "source",
+        references=[wvc.config.ReferenceProperty(name="ref", target_collection=target.name)],
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    if mt:
+        target.tenants.create("tenant1")
+        source.tenants.create("tenant1")
+        target = target.with_tenant("tenant1")
+        source = source.with_tenant("tenant1")
+
+    uuid_target1 = target.data.insert({})
+
+    role_name = _sanitize_role_name(request.node.name)
+    admin_client.roles.delete(role_name)
+
+    uuid_source = source.data.insert(properties={}, references={"ref": uuid_target1})
+    source.data.reference_add(
+        from_uuid=uuid_source,
+        from_property="ref",
+        to=uuid_target1,
+    )
+
+    required_permissions = [
+        Permissions.data(collection=source.name, delete=True, read=True),
+        Permissions.data(collection=target.name, read=True),
+    ]
+
+    # failing permissions first, so the object isn't actually deleted
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            assert (
+                len(source) == 1
+            )  # uses aggregate in background, cannot do that with restricted user
+
+            source_no_rights = custom_client.collections.get(
+                source.name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+
+            # deletion does not work
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.delete_many(
+                    where=wvc.query.Filter.by_ref("ref").by_id().equal(uuid_target1)
+                )
+            assert "forbidden" in e.value.args[0]
+            assert (
+                len(source) == 1
+            )  # uses aggregate in background, cannot do that with restricted user
+
+    with role_wrapper(admin_client, request, required_permissions):
+        assert len(source) == 1  # uses aggregate in background, cannot do that with restricted user
+
+        source_no_rights = custom_client.collections.get(
+            source.name
+        )  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+
+        ret = source_no_rights.data.delete_many(
+            where=wvc.query.Filter.by_ref("ref").by_id().equal(uuid_target1)
+        )
+        assert ret.successful == 1
+        assert len(source) == 0  # uses aggregate in background, cannot do that with restricted user
+
+    admin_client.collections.delete([target.name, source.name])
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_search_with_filter_and_return(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+) -> None:
+    col_name = _sanitize_role_name(request.node.name)
+
+    admin_client.collections.delete([col_name + "target", col_name + "source"])
+    # create two collections with some objects to test refs
+    target = admin_client.collections.create(
+        name=col_name + "target",
+        properties=[wvc.config.Property(name="prop", data_type=wvc.config.DataType.TEXT)],
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    source = admin_client.collections.create(
+        name=col_name + "source",
+        references=[wvc.config.ReferenceProperty(name="ref", target_collection=target.name)],
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    if mt:
+        target.tenants.create("tenant1")
+        source.tenants.create("tenant1")
+        target = target.with_tenant("tenant1")
+        source = source.with_tenant("tenant1")
+
+    uuid_target1 = target.data.insert({"prop": "word"})
+    source.data.insert(properties={}, references={"ref": uuid_target1})
+
+    role_name = _sanitize_role_name(request.node.name)
+    admin_client.roles.delete(role_name)
+
+    required_permissions = [
+        Permissions.data(collection=[source.name], read=True),
+        Permissions.data(collection=[target.name], read=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(
+            source.name
+        )  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+
+        ret_filter = source_no_rights.query.fetch_objects(
+            filters=wvc.query.Filter.by_ref("ref").by_id().equal(uuid_target1),
+        )
+        assert len(ret_filter.objects) == 1
+
+        ret_return = source_no_rights.query.fetch_objects(
+            return_references=wvc.query.QueryReference(
+                link_on="ref",
+                return_properties=["prop"],
+            ),
+        )
+        assert len(ret_return.objects[0].references["ref"].objects) == 1
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                source.name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.query.fetch_objects(
+                    filters=wvc.query.Filter.by_ref("ref").by_id().equal(uuid_target1)
+                )
+            assert "forbidden" in e.value.args[0]
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.query.fetch_objects(
+                    return_references=wvc.query.QueryReference(
+                        link_on="ref",
+                        return_properties=["prop"],
+                    ),
+                )
+            assert "forbidden" in e.value.args[0]
+
+    admin_client.collections.delete([target.name, source.name])
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_batch_ref(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    col_name = _sanitize_role_name(request.node.name)
+    admin_client.collections.delete(
+        [col_name + "target1", col_name + "target2", col_name + "source"]
+    )
+    # create two collections with some objects to test refs
+    target1 = admin_client.collections.create(
+        name=col_name + "target1",
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    target2 = admin_client.collections.create(
+        name=col_name + "target2",
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    source = admin_client.collections.create(
+        name=col_name + "source",
+        references=[
+            wvc.config.ReferenceProperty(name="ref1", target_collection=target1.name),
+            wvc.config.ReferenceProperty(name="ref2", target_collection=target2.name),
+        ],
+        multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+    )
+    if mt:
+        target1.tenants.create("tenant1")
+        target2.tenants.create("tenant1")
+        source.tenants.create("tenant1")
+        target1 = target1.with_tenant("tenant1")
+        target2 = target2.with_tenant("tenant1")
+        source = source.with_tenant("tenant1")
+
+    source.config.add_reference(
+        wvc.config.ReferenceProperty(name="self", target_collection=source.name)
+    )
+
+    uuid_target1 = target1.data.insert({})
+    uuid_target2 = target2.data.insert({})
+    uuid_source = source.data.insert(properties={})
+    role_name = _sanitize_role_name(request.node.name)
+    admin_client.roles.delete(role_name)
+
+    # self reference
+    required_permissions = [
+        Permissions.collections(collection=source.name, read_config=True),
+        Permissions.data(collection=source.name, read=True, update=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(
+            source.name
+        )  # no network call => no RBAC check
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+
+        ret = source_no_rights.data.reference_add_many(
+            [DataReference(from_property="self", from_uuid=uuid_source, to_uuid=uuid_source)]
+        )
+        assert len(ret.errors) == 0
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            source_no_rights = custom_client.collections.get(
+                source.name
+            )  # no network call => no RBAC check
+            if mt:
+                source_no_rights = source_no_rights.with_tenant("tenant1")
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                source_no_rights.data.reference_add_many(
+                    [
+                        DataReference(
+                            from_property="self", from_uuid=uuid_source, to_uuid=uuid_source
+                        )
+                    ]
+                )
+            assert e.value.status_code == 403
+
+    # ref to one target
+    required_permissions = [
+        Permissions.collections(collection=source.name, read_config=True),
+        Permissions.data(collection=[source.name, target1.name], read=True),
+        Permissions.data(collection=source.name, update=True),
+        Permissions.collections(collection=target1.name, read_config=True),
+    ]
+
+    with role_wrapper(admin_client, request, required_permissions):
+        source_no_rights = custom_client.collections.get(source.name)
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+
+        ret = source_no_rights.data.reference_add_many(
+            [
+                DataReference(from_property="self", from_uuid=uuid_source, to_uuid=uuid_source),
+                DataReference(from_property="ref1", from_uuid=uuid_source, to_uuid=uuid_target1),
+            ]
+        )
+        assert len(ret.errors) == 0
+
+    # without read permission for target that one reference fails
+    # no rights to read target class
+    with role_wrapper(admin_client, request, required_permissions[:-1]):
+        source_no_rights = custom_client.collections.get(source.name)
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        ret = source_no_rights.data.reference_add_many(
+            [
+                DataReference(from_property="self", from_uuid=uuid_source, to_uuid=uuid_source),
+                DataReference(from_property="ref1", from_uuid=uuid_source, to_uuid=uuid_target1),
+            ]
+        )
+
+        assert len(ret.errors) == 1
+        assert "forbidden" in ret.errors[1].message
+
+    # ref to two targets
+    ref2_required_permissions = [
+        Permissions.collections(collection=[source.name, target1.name], read_config=True),
+        Permissions.data(collection=source.name, update=True),
+        Permissions.data(collection=[source.name, target1.name, target2.name], read=True),
+        Permissions.collections(collection=target2.name, read_config=True),
+    ]
+
+    with role_wrapper(admin_client, request, ref2_required_permissions):
+        source_no_rights = custom_client.collections.get(source.name)
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        ret = source_no_rights.data.reference_add_many(
+            [
+                DataReference(from_property="self", from_uuid=uuid_source, to_uuid=uuid_source),
+                DataReference(from_property="ref1", from_uuid=uuid_source, to_uuid=uuid_target1),
+                DataReference(from_property="ref2", from_uuid=uuid_source, to_uuid=uuid_target2),
+            ]
+        )
+        assert len(ret.errors) == 0
+
+    # without read permission for target collection config, references TO that collection fail
+    with role_wrapper(admin_client, request, ref2_required_permissions[:-1]):
+        source_no_rights = custom_client.collections.get(source.name)
+        if mt:
+            source_no_rights = source_no_rights.with_tenant("tenant1")
+        ret = source_no_rights.data.reference_add_many(
+            [
+                DataReference(from_property="self", from_uuid=uuid_source, to_uuid=uuid_source),
+                DataReference(from_property="ref1", from_uuid=uuid_source, to_uuid=uuid_target1),
+                DataReference(from_property="ref2", from_uuid=uuid_source, to_uuid=uuid_target2),
+            ]
+        )
+
+        # only target where we miss permissions is failing
+        assert len(ret.errors) == 1
+        assert "forbidden" in ret.errors[2].message
+
+    admin_client.collections.delete(
+        [col_name + "target1", col_name + "target2", col_name + "source"]
+    )

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_rbac_search_grpc.py

@@ -0,0 +1,68 @@
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from weaviate.rbac.models import Permissions
+from _pytest.fixtures import SubRequest
+from .conftest import _sanitize_role_name, RoleWrapperProtocol, generate_missing_permissions
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_rbac_search(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol, mt: bool
+):
+    name_collection1 = _sanitize_role_name(request.node.name) + "col1"
+    name_collection2 = _sanitize_role_name(request.node.name) + "col2"
+    admin_client.collections.delete([name_collection1, name_collection2])
+    name_role = _sanitize_role_name(request.node.name) + "role"
+    admin_client.roles.delete(name_role)
+
+    col1 = admin_client.collections.create(
+        name=name_collection1, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+    col2 = admin_client.collections.create(
+        name=name_collection2, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+
+    if mt:
+        col1.tenants.create("tenant1")
+        col2.tenants.create("tenant1")
+        col1 = col1.with_tenant("tenant1")
+        col2 = col2.with_tenant("tenant1")
+
+    col1.data.insert({})
+    col2.data.insert({})
+
+    # with correct rights
+    required_permissions = [
+        Permissions.data(collection=col1.name, read=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        col_no_rights = custom_client.collections.get(col1.name)  # no network call => no RBAC check
+        if mt:
+            col_no_rights = col_no_rights.with_tenant("tenant1")
+        res = col_no_rights.query.fetch_objects()
+        assert len(res.objects) == 1
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            col_no_rights = custom_client.collections.get(
+                col1.name
+            )  # no network call => no RBAC check
+            if mt:
+                col_no_rights = col_no_rights.with_tenant("tenant1")
+
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                col_no_rights.query.fetch_objects()
+            assert e.value.status_code == 7
+
+    # rights for wrong collection
+    wrong_collection = Permissions.collections(collection=col2.name, read_config=True)
+    with role_wrapper(admin_client, request, wrong_collection):
+        col_no_rights = custom_client.collections.get(col1.name)  # no network call => no RBAC check
+        if mt:
+            col_no_rights = col_no_rights.with_tenant("tenant1")
+        with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+            col_no_rights.query.fetch_objects()
+        assert e.value.status_code == 7

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_roles.py

@@ -0,0 +1,33 @@
+import pytest
+import weaviate
+from _pytest.fixtures import SubRequest
+from weaviate.rbac.models import Permissions
+
+from .conftest import _sanitize_role_name, role_wrapper, RoleWrapperProtocol
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+def test_rbac_with_regexp(
+    request: SubRequest, admin_client, custom_client, role_wrapper: RoleWrapperProtocol
+):
+    name = _sanitize_role_name(request.node.name)
+    base = "python_"
+    python_name = base + name
+    admin_client.collections.delete([name, python_name])
+    admin_client.collections.create(name=name)
+    admin_client.collections.create(name=python_name)
+
+    with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+        custom_client.collections.delete(python_name)
+
+    # can delete everything starting with "python_" but nothing else
+    required_permissions = [
+        Permissions.collections(collection="*", read_config=True),
+        Permissions.collections(collection=base + "*", delete_collection=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        custom_client.collections.delete(python_name)
+        with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+            custom_client.collections.delete(name)
+    admin_client.collections.delete([name, python_name])

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/rbac/test_schema.py

@@ -0,0 +1,210 @@
+import pytest
+import weaviate
+import weaviate.classes as wvc
+from weaviate.rbac.models import Permissions
+from _pytest.fixtures import SubRequest
+from .conftest import _sanitize_role_name, RoleWrapperProtocol, generate_missing_permissions
+
+pytestmark = pytest.mark.xdist_group(name="rbac")
+
+
+def test_rbac_collection_create(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest
+):
+    name = _sanitize_role_name(request.node.name) + "col"
+    admin_client.collections.delete(name)
+    required_permissions = [
+        Permissions.collections(collection=name, read_config=True, create_collection=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        custom_client.collections.create(name=name)
+        admin_client.collections.delete(name)
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                custom_client.collections.create(name=name)
+            assert e.value.status_code == 403
+            assert "forbidden" in e.value.args[0]
+    admin_client.collections.delete(name)
+
+
+@pytest.mark.parametrize("mt", [True, False])
+def test_rbac_collection_create_with_ref(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest, mt: bool
+):
+    name_target = _sanitize_role_name(request.node.name) + "target"
+    name_source = _sanitize_role_name(request.node.name) + "source"
+    admin_client.collections.delete([name_target, name_source])
+    target = admin_client.collections.create(
+        name=name_target, multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt)
+    )
+
+    required_permissions = [
+        Permissions.collections(collection=[name_source, target.name], read_config=True),
+        Permissions.collections(collection=name_source, create_collection=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        custom_client.collections.create(
+            name=name_source,
+            multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+            references=[wvc.config.ReferenceProperty(name="ref", target_collection=target.name)],
+        )
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                custom_client.collections.create(
+                    name=name_source,
+                    multi_tenancy_config=wvc.config.Configure.multi_tenancy(enabled=mt),
+                    references=[
+                        wvc.config.ReferenceProperty(name="ref", target_collection=target.name)
+                    ],
+                )
+            assert e.value.status_code == 403
+            assert "forbidden" in e.value.args[0]
+
+    admin_client.collections.delete([name_target, name_source])
+
+
+def test_rbac_collection_read(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest
+):
+    name = _sanitize_role_name(request.node.name) + "col"
+    admin_client.collections.delete(name)
+    admin_client.collections.create(name=name)
+
+    required_permissions = Permissions.collections(collection=name, read_config=True)
+    with role_wrapper(admin_client, request, required_permissions):
+        col = custom_client.collections.get(name=name)
+        assert col.config.get() is not None
+
+    with role_wrapper(admin_client, request, []):
+        col = custom_client.collections.get(name=name)
+        with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+            col.config.get()
+        assert e.value.status_code == 403
+        assert "forbidden" in e.value.args[0]
+
+    admin_client.collections.delete(name)
+
+
+def test_rbac_schema_read(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest
+):
+    name = _sanitize_role_name(request.node.name) + "col"
+    admin_client.collections.delete(name)
+    admin_client.collections.create(name=name)
+
+    required_permission = Permissions.collections(collection="*", read_config=True)
+    with role_wrapper(admin_client, request, required_permission):
+        custom_client.collections.list_all()
+
+    with role_wrapper(admin_client, request, []):
+        collections = custom_client.collections.list_all()
+        assert len(collections) == 0
+
+    admin_client.collections.delete(name)
+
+def test_rbac_schema_read_filtered_collections(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest
+):    
+    base_name = _sanitize_role_name(request.node.name)
+    allowed_collection = f"{base_name}_allowed"
+    restricted_collection = f"{base_name}_restricted"
+    
+    for name in [allowed_collection, restricted_collection]:
+        admin_client.collections.delete(name)
+        admin_client.collections.create(name=name)
+
+
+    required_permission = Permissions.collections(collection=allowed_collection, read_config=True)
+    with role_wrapper(admin_client, request, required_permission):
+        collections = custom_client.collections.list_all()    
+        collection_names = {name.lower() for name in collections.keys()}
+        assert len(collection_names) == 1
+        assert allowed_collection.lower() in collection_names
+        assert restricted_collection.lower() not in collection_names
+    
+    admin_client.collections.delete(allowed_collection)
+    admin_client.collections.delete(restricted_collection)
+    
+def test_rbac_collection_update(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest
+):
+    name = _sanitize_role_name(request.node.name) + "col"
+    admin_client.collections.delete(name)
+    admin_client.collections.create(name=name)
+
+    required_permissions = [
+        Permissions.collections(collection=name, read_config=True, update_config=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        col_custom = custom_client.collections.get(name)
+        col_custom.config.update(description="test")
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            col_custom = custom_client.collections.get(name)
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                col_custom.config.update(description="test")
+            assert e.value.status_code == 403
+            assert "forbidden" in e.value.args[0]
+
+    admin_client.collections.delete(name)
+
+
+def test_rbac_collection_update_with_ref(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest
+):
+    name_target = _sanitize_role_name(request.node.name) + "target"
+    name_source = _sanitize_role_name(request.node.name) + "source"
+    admin_client.collections.delete([name_target, name_source])
+    admin_client.collections.create(name=name_target)
+    admin_client.collections.create(name=name_source)
+
+    required_permissions = [
+        Permissions.collections(collection=[name_target, name_source], read_config=True),
+        Permissions.collections(collection=name_source, update_config=True),
+    ]
+    with role_wrapper(admin_client, request, required_permissions):
+        col_custom = custom_client.collections.get(name_source)
+        col_custom.config.add_reference(
+            wvc.config.ReferenceProperty(name="self1", target_collection=name_target)
+        )
+
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            col_custom = custom_client.collections.get(name_source)
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                col_custom.config.add_reference(
+                    wvc.config.ReferenceProperty(name="self2", target_collection=name_target)
+                )
+            assert e.value.status_code == 403
+            assert "forbidden" in e.value.args[0]
+
+    admin_client.collections.delete([name_target, name_source])
+
+
+def test_rbac_collection_delete(
+    admin_client, custom_client, role_wrapper: RoleWrapperProtocol, request: SubRequest
+):
+    name = _sanitize_role_name(request.node.name) + "col"
+    admin_client.collections.delete(name)
+
+    required_permissions = [
+        Permissions.collections(collection=name, delete_collection=True, read_config=True),
+    ]
+    for permission in generate_missing_permissions(required_permissions):
+        with role_wrapper(admin_client, request, permission):
+            with pytest.raises(weaviate.exceptions.InsufficientPermissionsError) as e:
+                custom_client.collections.delete(name)
+            assert e.value.status_code == 403
+            assert "forbidden" in e.value.args[0]
+            assert admin_client.collections.get(name) is not None
+
+    with role_wrapper(admin_client, request, required_permissions):
+        custom_client.collections.delete(name)
+        assert not admin_client.collections.exists(name)
+
+    admin_client.collections.delete(name)

platform/dbops/binaries/weaviate-src/test/benchmark/remote/README.md

@@ -0,0 +1,52 @@
+This folder contains scripts to help execute the benchmark remotely on a GCP
+VM.
+
+## Requirements
+
+- Bash
+- gcloud (logged in and permissions to `semi-automated-benchmarking` project
+- terraform
+
+## Usage
+
+From the root folder run
+
+```
+test/benchmark/remote/run.sh --all
+```
+
+To run the whole benchmark suite. The `--all` command will:
+
+- Check that `gcloud` and `terraform` are installed locally
+- Spin up a machine in GCP
+- Install the dependencies on this machine
+- Clone Weaviate
+- Check out the same commit that is check out locally
+- Run the benchmarks script
+- Copy the results file to the local machine
+- Destroy the machine
+
+If any of the command fails the machine will be destroyed.
+
+## Debugging
+
+You can also run all commands individually, simply run the command without
+parameters to list all possible options.
+
+To do all steps (including spinning up a machine) that happen _before_ running
+the benchmarks you can invoke it with the `--prepare` option. To get an
+interactive ssh session into the machine, use `--ssh`. To destroy the machine
+at an arbitrary point run `--delete_machine`.
+
+## Run on arbitrary branch
+
+*Note: Checking out a branch that does not yet have the scripts from this
+folder, will fail. You need a branch created after this script was initially
+built or has been rebased on top of it.*
+
+```
+test/benchmark/remote/run.sh --prepare
+test/benchmark/remote/run.sh --checkout <name-of-your-branch-or-commit>
+test/benchmark/remote/run.sh --benchmark
+test/benchmark/remote/run.sh --delete_machine
+```

platform/dbops/binaries/weaviate-src/test/benchmark/remote/run.sh

@@ -0,0 +1,156 @@
+#!/bin/bash
+
+PROJECT=semi-automated-benchmarking
+ZONE=us-central1-a
+INSTANCE=automated-loadtest
+GOVERSION=https://go.dev/dl/go1.18.4.linux-amd64.tar.gz
+FILE_PREFIX=${FILE_PREFIX:-""}
+
+set -eou pipefail
+
+# change to script directory
+cd "${0%/*}" || exit
+
+function main() {
+  while [[ "$#" -gt 0 ]]; do
+      case $1 in
+          --all) run_all; exit 0 ;;
+          --create_machine) create_machine; exit 0 ;;
+          --clone_repository) clone_repository; exit 0;;
+          --delete_machine) delete_machine; exit 0;;
+          --install_dependencies) install_dependencies; exit 0;;
+          --benchmark) benchmark; exit 0;;
+          --prepare) prepare; exit 0;;
+          --checkout) checkout "$2" ; exit 0;;
+          --ssh) interactive_ssh; exit 0;;
+          *) echo "Unknown parameter passed: $1"; exit 1 ;;
+      esac
+      shift
+  done
+
+  print_help
+}
+
+function print_help() {
+  echo "Valid arguments include:"
+  echo ""
+  echo "  --all               Run everything, including machine creation & destruction"
+  echo "  --prepare           Create Machine & run all the steps prior to benchmark execution"
+  echo "  --create_machine    Only create machine"
+  echo "  --delete_machine    Stop & Delete running machine"
+  echo "  --clone_repository  Clone and checkout Weaviate repo at specified commit"
+  echo "  --checkout          Checkout arbitrary branch or commit"
+  echo "  --ssh               Interactive SSH session"
+}
+
+function run_all() {
+  trap delete_machine EXIT
+
+  prepare
+  benchmark
+}
+
+function prepare() {
+  check
+  create_machine
+  install_dependencies
+  clone_repository
+}
+
+function check() {
+  echo_green "Checking required dependencies"
+  if ! command -v gcloud &> /dev/null
+  then
+      echo_red "Missing gcloud binary"
+      return 1
+  fi
+
+  if ! command -v terraform &> /dev/null
+  then
+      echo_red "Missing terraform binary"
+      return 1
+  fi
+
+  echo "Ready to go!"
+}
+
+function create_machine() {
+  (cd terraform && terraform init)
+  (cd terraform && terraform apply -auto-approve)
+  echo "Sleeping for 10s, so first ssh doesn't fail. This should be improved through polling"
+  sleep 10
+}
+
+function delete_machine() {
+  (cd terraform && terraform destroy -auto-approve)
+}
+
+function install_dependencies() {
+  ssh_command "sudo apt-get update && sudo apt-get install -y git git-lfs curl"
+  ssh_command "ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts"
+  install_go
+  install_docker
+}
+
+function install_go {
+  ssh_command "curl -Lo go.tar.gz $GOVERSION"
+  ssh_command "sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go.tar.gz"
+  ssh_command 'echo '"'"'PATH=$PATH:/usr/local/go/bin'"'"' >> ~/.profile'
+  ssh_command "go version"
+}
+
+function install_docker() {
+  ssh_command "if ! command -v docker &> /dev/null; then curl -fsSL https://get.docker.com -o get-docker.sh && sh ./get-docker.sh; fi"
+  ssh_command "sudo groupadd docker || true"
+  ssh_command "sudo usermod -aG docker $USER"
+}
+
+function clone_repository() {
+  ref=$(git rev-parse --abbrev-ref HEAD)
+  echo_green "Cloning weaviate repo to branch $ref"
+  ssh_command "cd; [ ! -d weaviate ] && git clone --depth 1 --branch $ref https://github.com/weaviate/weaviate.git weaviate || true"
+  ssh_command "cd weaviate; git-lfs install; git-lfs pull"
+}
+
+function checkout() {
+  ref="$1"
+  ssh_command "cd weaviate; git checkout $ref"
+}
+
+function benchmark() {
+  echo_green "Run benchmarks on remote machine"
+  ssh_command "echo "stop all running docker containers"; docker rm -f $(docker ps -q) || true"
+  ssh_command "cd ~/weaviate; rm test/benchmark/benchmark_results.json || true"
+  ssh_command "cd ~/weaviate; test/benchmark/run_performance_tracker.sh"
+  echo_green "Copy results file to local machine"
+  filename="${FILE_PREFIX}benchmark_results_$(date +%s).json"
+  scp_command "$INSTANCE:~/weaviate/test/benchmark/benchmark_results.json" "$filename"
+  echo "Results file succesfully copied to ${PWD}/$filename"
+}
+
+
+function echo_green() {
+  green='\033[0;32m'
+  nc='\033[0m' 
+  echo -e "${green}${*}${nc}"
+}
+
+function echo_red() {
+  red='\033[0;31m'
+  nc='\033[0m' 
+  echo -e "${red}${*}${nc}"
+}
+
+function ssh_command() {
+  gcloud beta compute ssh --project=$PROJECT --zone=$ZONE  "$INSTANCE" --command="source ~/.profile; $1"
+}
+
+function scp_command() {
+  gcloud beta compute scp --project=$PROJECT --zone=$ZONE  "$@"
+}
+
+function interactive_ssh() {
+  gcloud beta compute ssh --project=$PROJECT --zone=$ZONE  "$INSTANCE"
+}
+
+main "$@"

platform/dbops/binaries/weaviate-src/test/benchmark/remote/terraform/.gitignore

@@ -0,0 +1,9 @@
+# Local .terraform directories
+**/.terraform/*
+
+.terraform.lock.hcl
+
+
+# .tfstate files
+*.tfstate
+*.tfstate.*

platform/dbops/binaries/weaviate-src/test/benchmark/remote/terraform/main.tf

@@ -0,0 +1,3 @@
+provider "google" {
+  project = "semi-automated-benchmarking"
+}

platform/dbops/binaries/weaviate-src/test/benchmark/remote/terraform/variables.tf

@@ -0,0 +1,4 @@
+variable "machine_type" {
+  type = string
+  default = "c2-standard-16"
+}

platform/dbops/binaries/weaviate-src/test/benchmark/remote/terraform/vm.tf

@@ -0,0 +1,23 @@
+resource "google_compute_instance" "default" {
+  name         = "automated-loadtest"
+  machine_type = var.machine_type
+  zone         = "us-central1-a"
+
+  tags = ["automated-loadtest"]
+
+  boot_disk {
+    initialize_params {
+      image = "debian-cloud/debian-11"
+      size = 100
+      type = "pd-ssd"
+    }
+  }
+
+  network_interface {
+    network = "default"
+
+    access_config {
+      // Ephemeral public IP
+    }
+  }
+}

platform/dbops/binaries/weaviate-src/test/benchmark_bm25/cmd/import.go

@@ -0,0 +1,247 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/batch"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/benchmark_bm25/lib"
+)
+
+func init() {
+	rootCmd.AddCommand(importCmd)
+	importCmd.PersistentFlags().IntVarP(&BatchSize, "batch-size", "b", DefaultBatchSize, "number of objects in a single import batch")
+	importCmd.PersistentFlags().IntVarP(&MultiplyProperties, "multiply-properties", "m", DefaultMultiplyProperties, "create artifical copies of real properties by setting a value larger than 1. The properties have identical contents, so it won't alter results, but leads to many more calculations.")
+	importCmd.PersistentFlags().BoolVarP(&Vectorizer, "vectorizer", "v", DefaultVectorizer, "Vectorize import data with default vectorizer")
+	importCmd.PersistentFlags().IntVarP(&QueriesCount, "count", "c", DefaultQueriesCount, "run only the specified amount of queries, negative numbers mean unlimited")
+	importCmd.PersistentFlags().IntVarP(&FilterObjectPercentage, "filter", "f", DefaultFilterObjectPercentage, "The given percentage of objects are filtered out. Off by default, use <=0 to disable")
+	importCmd.PersistentFlags().Float32VarP(&Alpha, "alpha", "a", DefaultAlpha, "Weighting for keyword vs vector search. Alpha = 0 (Default) is pure BM25 search.")
+	importCmd.PersistentFlags().StringVarP(&Ranking, "ranking", "r", DefaultRanking, "Which ranking algorithm should be used for hybrid search, rankedFusion (default) and relativeScoreFusion.")
+	importCmd.PersistentFlags().IntVarP(&QueriesInterval, "query-interval", "i", DefaultQueriesInterval, "run queries every this number of inserts")
+	importCmd.PersistentFlags().IntVarP(&Limit, "limit", "l", DefaultLimit, "Limit the number of results returned by the query")
+	importCmd.PersistentFlags().BoolVarP(&AdditionalExplanations, "additional-explanations", "e", DefaultAdditionalExplanations, "Request additional explanations for the query results")
+	importCmd.PersistentFlags().BoolVarP(&PrintDetailedResults, "print-detailed-results", "p", DefaultPrintDetailedResults, "Print detailed results")
+}
+
+func parseData(data []lib.Corpus, datasetId string, batch *batch.ObjectsBatcher, i int) int {
+	total := 0
+	for _, corp := range data {
+		index := i + total
+		id := uuid.MustParse(fmt.Sprintf("%032x", index)).String()
+		props := map[string]interface{}{
+			"modulo_10":   index % 10,
+			"modulo_100":  index % 100,
+			"modulo_1000": index % 1000,
+		}
+
+		for key, value := range corp {
+			props[key] = value
+		}
+
+		batch.WithObjects(&models.Object{
+			ID:         strfmt.UUID(id),
+			Class:      lib.ClassNameFromDatasetID(datasetId),
+			Properties: props,
+		})
+
+		total++
+	}
+	return total
+}
+
+type IndexingExperimentResult struct {
+	// The name of the dataset
+	Dataset string
+	// The number of objects in the dataset
+	Objects int
+	// The batch size used for importing
+	MultiplyProperties int
+	// Docs where vectorized
+	Vectorize bool
+	// The time it took to import the dataset
+	ImportTime float64
+	// Average time to import 1000 objects
+	ImportTimePer1000 float64
+	// Objects per second
+	ObjectsPerSecond float64
+}
+
+var importCmd = &cobra.Command{
+	Use:   "import",
+	Short: "Import a dataset (or multiple datasets) into Weaviate",
+
+	RunE: func(cmd *cobra.Command, args []string) error {
+		client, err := lib.ClientFromOrigin(Origin)
+		if err != nil {
+			return err
+		}
+
+		ok, err := client.Misc().LiveChecker().Do(context.Background())
+		if err != nil {
+			return fmt.Errorf("weaviate is not ready at %v: %w", Origin, err)
+		}
+
+		if !ok {
+			return fmt.Errorf("weaviate is not ready")
+		}
+
+		datasets, err := lib.ParseDatasetConfig(DatasetConfigPath)
+		if err != nil {
+			return fmt.Errorf("parse dataset cfg file: %w", err)
+		}
+
+		//if err := client.Schema().AllDeleter().Do(context.Background()); err != nil {
+		//	return fmt.Errorf("clear schema prior to import: %w", err)
+		//}
+
+		experimentResults := make([]IndexingExperimentResult, len(datasets.Datasets))
+		queryResults := make([]*QueryExperimentResult, 0)
+
+		for di, dataset := range datasets.Datasets {
+
+			// delete the class if it exists
+			if err := client.Schema().ClassDeleter().WithClassName(lib.ClassNameFromDatasetID(dataset.ID)).Do(context.Background()); err != nil {
+				return fmt.Errorf("delete class for %s: %w", dataset, err)
+			}
+
+			if err := client.Schema().ClassCreator().
+				WithClass(lib.SchemaFromDataset(dataset, Vectorizer)).
+				Do(context.Background()); err != nil {
+				return fmt.Errorf("create schema for %s: %w", dataset, err)
+			}
+			log.Print("importing dataset " + dataset.ID)
+			queries := make([]lib.Query, 0)
+			if QueriesInterval != -1 {
+				log.Print("parse queries")
+				queries, err = lib.ParseQueries(dataset, QueriesCount)
+				if err != nil {
+					return err
+				}
+				log.Print("queries parsed")
+			}
+
+			start := time.Now()
+			startBatch := time.Now()
+			batch := client.Batch().ObjectsBatcher()
+
+			indexCount := 0
+
+			c, err := lib.ParseCorpi(dataset, MultiplyProperties)
+			if err != nil {
+				return err
+			}
+
+			i := 0
+			for c.Next(BatchSize) == nil {
+				data := c.Data
+
+				if len(data) == 0 {
+					break
+				}
+				parsedCount := parseData(data, dataset.ID, batch, i)
+				i += parsedCount
+				indexCount += parsedCount
+
+				if indexCount%BatchSize == 0 {
+					br, err := batch.Do(context.Background())
+					if err != nil {
+						return fmt.Errorf("batch %d: %w", indexCount, err)
+					}
+
+					if err := lib.HandleBatchResponse(br); err != nil {
+						return err
+					}
+				}
+
+				if indexCount%BatchSize == 0 {
+					totalTimeBatch := time.Since(startBatch).Seconds()
+					totalTime := time.Since(start).Seconds()
+					startBatch = time.Now()
+					log.Printf("imported %d objects in %.3f, time per 1k objects: %.3f, objects per second: %.0f", indexCount, totalTimeBatch, totalTime/float64(indexCount)*1000, float64(indexCount)/totalTime)
+				}
+
+				if QueriesInterval > 0 && indexCount%QueriesInterval == 0 {
+					result, err := query(client, queries, dataset, indexCount)
+					if err != nil {
+						return fmt.Errorf("query: %w", err)
+					}
+					queryResults = append(queryResults, result)
+
+				}
+			}
+
+			if len(c.Data) != 0 {
+				data := c.Data
+				parsedCount := parseData(data, dataset.ID, batch, i)
+				i += parsedCount
+				indexCount += parsedCount
+				// we need to send one final batch
+				br, err := batch.Do(context.Background())
+				if err != nil {
+					return fmt.Errorf("final batch: %w", err)
+				}
+				if err := lib.HandleBatchResponse(br); err != nil {
+					return err
+				}
+				totalTimeBatch := time.Since(startBatch).Seconds()
+				totalTime := time.Since(start).Seconds()
+				log.Printf("imported %d objects in %.3f, time per 1k objects: %.3f, objects per second: %.0f", indexCount, totalTimeBatch, totalTime/float64(indexCount)*1000, float64(indexCount)/totalTime)
+			}
+
+			totalTime := time.Since(start).Seconds()
+			log.Printf("importing finished %d objects in %.3f, time per 1k objects: %.3f, objects per second: %.0f", indexCount, totalTime, totalTime/float64(indexCount)*1000, float64(indexCount)/totalTime)
+
+			if QueriesInterval != -1 && indexCount%QueriesInterval != 0 {
+				// run queries after full import
+				result, err := query(client, queries, dataset, indexCount)
+				if err != nil {
+					return fmt.Errorf("query: %w", err)
+				}
+				queryResults = append(queryResults, result)
+			}
+
+			experimentResults[di] = IndexingExperimentResult{
+				Dataset:            dataset.ID,
+				Objects:            indexCount,
+				MultiplyProperties: MultiplyProperties,
+				Vectorize:          Vectorizer,
+				ImportTime:         time.Since(start).Seconds(),
+				ImportTimePer1000:  time.Since(start).Seconds() / float64(indexCount) * 1000,
+				ObjectsPerSecond:   float64(indexCount) / time.Since(start).Seconds(),
+			}
+		}
+		// pretty print results fas TSV
+		fmt.Printf("\nIndexing Results:\n")
+		fmt.Printf("Dataset\tObjects\tMultiplyProperties\tVectorizer\tImportTime\tImportTimePer1000\tObjectsPerSecond\n")
+		for _, result := range experimentResults {
+			fmt.Printf("%s\t%d\t%d\t%t\t%.3f\t%.3f\t%.0f\n", result.Dataset, result.Objects, result.MultiplyProperties, result.Vectorize, result.ImportTime, result.ImportTimePer1000, result.ObjectsPerSecond)
+		}
+
+		fmt.Printf("\nQuery Results:\n")
+		fmt.Printf("Dataset\tObjects\tQueries\tFilterObjectPercentage\tAlpha\tRanking\tQueryTime\tQueryTimePer1000\tQueriesPerSecond\tQueryTimePer1000000Documents\tMin\tMax\tP50\tP90\tP99\tnDCG\tP@1\tP@5\n")
+		for _, result := range queryResults {
+			ranking, _ := strconv.ParseFloat(result.Ranking, 64) // Convert result.Ranking to float64
+			fmt.Printf("%s\t%d\t%d\t%d\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n", result.Dataset, result.Objects, result.Queries, result.FilterObjectPercentage, result.Alpha, ranking, result.TotalQueryTime, result.AvgQueryTime.Seconds(), result.QueriesPerSecond, result.QueryTimePer1000000Documents, float32(result.Min.Milliseconds())/1000.0, float32(result.Max.Milliseconds())/1000.0, float32(result.P50.Milliseconds())/1000.0, float32(result.P90.Milliseconds())/1000.0, float32(result.P99.Milliseconds())/1000.0, result.Scores.CurrentNDCG(), result.Scores.CurrentPrecisionAt1(), result.Scores.CurrentPrecisionAt5())
+		}
+
+		return nil
+	},
+}

platform/dbops/binaries/weaviate-src/test/benchmark_bm25/cmd/query.go

@@ -0,0 +1,288 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package cmd
+
+import (
+	"context"
+	"encoding/csv"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/filters"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/benchmark_bm25/lib"
+)
+
+type QueryExperimentResult struct {
+	// The name of the dataset
+	Dataset string
+	// Dataset size
+	Objects int
+	// Query count
+	Queries int
+	// Filter object percentage
+	FilterObjectPercentage int
+	// Alpha
+	Alpha float32
+	// Ranking
+	Ranking string
+	// The time it took to query the dataset
+	TotalQueryTime float64
+	// Average query time
+	AvgQueryTime time.Duration
+	// Average time to query per 1000 indexed objects
+	QueryTimePer1000000Documents float64
+	// Objects per second
+	QueriesPerSecond float64
+	// Min query time
+	Min time.Duration
+	// Max query time
+	Max time.Duration
+	// P50 query time
+	P50 time.Duration
+	// P90 query time
+	P90 time.Duration
+	// P95 query time
+	P99 time.Duration
+	// Scores
+	Scores lib.Scores
+}
+
+func init() {
+	rootCmd.AddCommand(queryCmd)
+	queryCmd.PersistentFlags().IntVarP(&QueriesCount, "count", "c", DefaultQueriesCount, "run only the specified amount of queries, negative numbers mean unlimited")
+	queryCmd.PersistentFlags().IntVarP(&FilterObjectPercentage, "filter", "f", DefaultFilterObjectPercentage, "The given percentage of objects are filtered out. Off by default, use <=0 to disable")
+	queryCmd.PersistentFlags().Float32VarP(&Alpha, "alpha", "a", DefaultAlpha, "Weighting for keyword vs vector search. Alpha = 0 (Default) is pure BM25 search.")
+	queryCmd.PersistentFlags().StringVarP(&Ranking, "ranking", "r", DefaultRanking, "Which ranking algorithm should be used for hybrid search, rankedFusion (default) and relativeScoreFusion.")
+	queryCmd.PersistentFlags().IntVarP(&Limit, "limit", "l", DefaultLimit, "Limit the number of results returned by the query")
+	queryCmd.PersistentFlags().BoolVarP(&AdditionalExplanations, "additional-explanations", "e", DefaultAdditionalExplanations, "Request additional explanations for the query results")
+	queryCmd.PersistentFlags().BoolVarP(&PrintDetailedResults, "print-detailed-results", "p", DefaultPrintDetailedResults, "Print detailed results")
+}
+
+func writeQueryResultsToFile(results *models.GraphQLResponse, filename, collection, queryId string, additionalExplanations bool) {
+	file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer file.Close()
+
+	writer := csv.NewWriter(file)
+	defer writer.Flush()
+
+	header := []string{"queryId", "id", "score"}
+	if additionalExplanations {
+		header = append(header, "explainScore")
+	}
+
+	// Write the header
+	writer.Write(header)
+	for _, obj := range results.Data["Get"].(map[string]interface{})[collection].([]interface{}) {
+		id := obj.(map[string]interface{})["_additional"].(map[string]interface{})["id"].(string)
+		score := obj.(map[string]interface{})["_additional"].(map[string]interface{})["score"].(string)
+
+		// round score to 2 decimal places
+		scoreFloat, err := strconv.ParseFloat(score, 64)
+		if err != nil {
+			log.Fatal(err)
+		}
+		score = fmt.Sprintf("%.2f", scoreFloat)
+
+		line := []string{queryId, id, score}
+		if additionalExplanations {
+			line = append(line, obj.(map[string]interface{})["_additional"].(map[string]interface{})["explainScore"].(string))
+		}
+
+		writer.Write(line)
+	}
+}
+
+func query(client *weaviate.Client, q lib.Queries, ds lib.Dataset, index int) (*QueryExperimentResult, error) {
+	propNameWithId := lib.SanitizePropName(ds.Queries.PropertyWithId)
+	propertiesToMatch := ds.Queries.PropertiesToMatch
+	for i := 0; i < len(propertiesToMatch); i++ {
+		propertiesToMatch[i] = lib.SanitizePropName(propertiesToMatch[i])
+	}
+	className := lib.ClassNameFromDatasetID(ds.ID)
+	times := []time.Duration{}
+	scores := lib.Scores{}
+
+	// unix timestamp as string
+	t := strconv.FormatInt(time.Now().Unix(), 10)
+	propName := strings.Join(propertiesToMatch, "_")
+	if len(propertiesToMatch) == 0 {
+		propName = "all"
+	}
+	if index >= 0 {
+		propName = propName + "_" + strconv.Itoa(index)
+	}
+	filename := t + "_" + className + "_" + propName + ".csv"
+
+	additionalFlags := "id"
+	if PrintDetailedResults {
+		additionalFlags = "id score explainScore"
+	}
+	for i, query := range q {
+		before := time.Now()
+		var queryBuilder *graphql.GetBuilder
+
+		queryBuilder = client.GraphQL().Get().WithClassName(className).WithLimit(Limit).WithFields(graphql.Field{Name: "_additional { " + additionalFlags + " }"}, graphql.Field{Name: propNameWithId})
+		if Alpha == 0 {
+			bm25 := &graphql.BM25ArgumentBuilder{}
+			bm25.WithQuery(query.Query)
+			bm25.WithProperties(propertiesToMatch...)
+			queryBuilder.WithBM25(bm25)
+		} else {
+			hybrid := &graphql.HybridArgumentBuilder{}
+			ranking := graphql.FusionType(Ranking)
+			hybrid.WithQuery(query.Query).WithAlpha(Alpha).WithFusionType(ranking)
+			hybrid.WithProperties(propertiesToMatch)
+			queryBuilder.WithHybrid(hybrid)
+		}
+		if FilterObjectPercentage > 0 {
+			filter := filters.Where()
+			filter.WithPath([]string{"modulo_100"})
+			filter.WithOperator(filters.GreaterThan)
+			filter.WithValueInt(int64(FilterObjectPercentage))
+			queryBuilder = queryBuilder.WithWhere(filter)
+		}
+		result, err := queryBuilder.Do(context.Background())
+		if err != nil {
+			return nil, err
+		}
+
+		if result.Errors != nil {
+			return nil, errors.New(result.Errors[0].Message)
+		}
+		times = append(times, time.Since(before))
+
+		// print result scores and ids to a csv file
+		if PrintDetailedResults {
+			queryId := strconv.Itoa(i)
+			writeQueryResultsToFile(result, filename, className, queryId, AdditionalExplanations)
+		}
+
+		logMsg := fmt.Sprintf("completed %d/%d queries.", i, len(q))
+
+		if len(query.MatchingIds) > 0 && len(ds.Queries.PropertyWithId) > 0 {
+			resultIds := result.Data["Get"].(map[string]interface{})[className].([]interface{})
+			if err := scores.AddResult(query.MatchingIds, resultIds, propNameWithId); err != nil {
+				return nil, err
+			}
+			logMsg += fmt.Sprintf("nDCG score: %.04f", scores.CurrentNDCG())
+		}
+		if i%1000 == 0 && i > 0 {
+			log.Print(logMsg)
+		}
+	}
+
+	meta, err := client.GraphQL().Aggregate().WithClassName(lib.ClassNameFromDatasetID(ds.ID)).
+		WithFields(graphql.Field{Name: "meta", Fields: []graphql.Field{{Name: "count"}}}).
+		Do(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	objCount := int(meta.Data["Aggregate"].(map[string]interface{})[lib.ClassNameFromDatasetID(ds.ID)].([]interface{})[0].(map[string]interface{})["meta"].(map[string]interface{})["count"].(float64))
+
+	stat := lib.AnalyzeLatencies(times)
+	stat.PrettyPrint()
+	scores.PrettyPrint()
+	totalTime := 0.0
+	for _, t := range times {
+		totalTime += t.Seconds()
+	}
+
+	result := QueryExperimentResult{
+		Dataset:                      ds.ID,
+		Objects:                      objCount,
+		Queries:                      len(q),
+		FilterObjectPercentage:       FilterObjectPercentage,
+		Alpha:                        Alpha,
+		Ranking:                      Ranking,
+		TotalQueryTime:               totalTime,
+		AvgQueryTime:                 stat.Mean,
+		QueriesPerSecond:             1 / stat.Mean.Seconds(),
+		QueryTimePer1000000Documents: float64(stat.Mean.Milliseconds()) * 1000000 / float64(objCount),
+		Min:                          stat.Min,
+		Max:                          stat.Max,
+		P50:                          stat.P50,
+		P90:                          stat.P90,
+		P99:                          stat.P99,
+		Scores:                       scores,
+	}
+
+	return &result, nil
+}
+
+var queryCmd = &cobra.Command{
+	Use:   "query",
+	Short: "Send queries for a dataset",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		client, err := lib.ClientFromOrigin(Origin)
+		if err != nil {
+			return err
+		}
+
+		ok, err := client.Misc().LiveChecker().Do(context.Background())
+		if err != nil {
+			return fmt.Errorf("weaviate is not ready: %w", err)
+		}
+
+		if !ok {
+			return fmt.Errorf("weaviate is not ready")
+		}
+		log.Print("weaviate is ready")
+
+		datasets, err := lib.ParseDatasetConfig(DatasetConfigPath)
+		if err != nil {
+			return fmt.Errorf("parse dataset cfg file: %w", err)
+		}
+
+		results := make([]*QueryExperimentResult, len(datasets.Datasets))
+		for di, ds := range datasets.Datasets {
+			log.Print("querying dataset " + ds.ID)
+			log.Print("parse queries")
+			q, err := lib.ParseQueries(ds, QueriesCount)
+			if err != nil {
+				return err
+			}
+			log.Print("queries parsed")
+			log.Print("start querying")
+
+			result, err := query(client, q, ds, -1)
+			if err != nil {
+				return err
+			}
+
+			results[di] = result
+
+		}
+
+		fmt.Printf("\nQuery Results:\n")
+		fmt.Printf("Dataset\tObjects\tQueries\tFilterObjectPercentage\tAlpha\tRanking\tQueryTime\tAvgQueryTime\tQueriesPerSecond\tQueryTimePer1000000Documents\tMin\tMax\tP50\tP90\tP99\tnDCG\tP@1\tP@5\n")
+		for _, result := range results {
+			ranking, _ := strconv.ParseFloat(result.Ranking, 64) // Convert result.Ranking to float64
+			fmt.Printf("%s\t%d\t%d\t%d\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n", result.Dataset, result.Objects, result.Queries, result.FilterObjectPercentage, result.Alpha, ranking, result.TotalQueryTime, result.AvgQueryTime.Seconds(), result.QueriesPerSecond, result.QueryTimePer1000000Documents, result.Min.Seconds(), result.Max.Seconds(), result.P50.Seconds(), result.P90.Seconds(), result.P99.Seconds(), result.Scores.CurrentNDCG(), result.Scores.CurrentPrecisionAt1(), result.Scores.CurrentPrecisionAt5())
+		}
+
+		return nil
+	},
+}

platform/dbops/binaries/weaviate-src/test/benchmark_bm25/cmd/root.go

@@ -0,0 +1,72 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	Origin                 string
+	DatasetConfigPath      string
+	BatchSize              int
+	QueriesCount           int
+	MultiplyProperties     int
+	FilterObjectPercentage int
+	QueriesInterval        int
+	Alpha                  float32
+	Ranking                string
+	Vectorizer             bool
+	Limit                  int
+	AdditionalExplanations bool
+	PrintDetailedResults   bool
+)
+
+const (
+	DefaultOrigin                 = "http://localhost:8080"
+	DefaultDatasetConfigPath      = "datasets.yml"
+	DefaultBatchSize              = 100
+	DefaultQueriesCount           = -1
+	DefaultQueriesInterval        = -1
+	DefaultMultiplyProperties     = 1
+	DefaultFilterObjectPercentage = 0
+	DefaultAlpha                  = 0
+	DefaultRanking                = "ranked_fusion"
+	DefaultVectorizer             = false
+	DefaultLimit                  = 100
+	DefaultAdditionalExplanations = false
+	DefaultPrintDetailedResults   = false
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "benchmarker",
+	Short: "benchmarker is a simple tool to obtain bm25 speed benchmarks",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		fmt.Printf("Run --help to see usage instructions.\n")
+		return nil
+	},
+}
+
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.PersistentFlags().StringVarP(&Origin, "origin", "o", DefaultOrigin, "origin (schema + host + port) where weaviate is running")
+	rootCmd.PersistentFlags().StringVar(&DatasetConfigPath, "dataset-config", DefaultDatasetConfigPath, "path to dataset config file")
+}

platform/dbops/binaries/weaviate-src/test/benchmark_bm25/lib/batch.go

@@ -0,0 +1,43 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func HandleBatchResponse(res []models.ObjectsGetResponse) error {
+	msgs := []string{}
+
+	for i, obj := range res {
+		if obj.Result.Errors == nil {
+			continue
+		}
+
+		if len(obj.Result.Errors.Error) == 0 {
+			continue
+		}
+
+		msg := fmt.Sprintf("at pos %d: %s", i, obj.Result.Errors.Error[0].Message)
+		msgs = append(msgs, msg)
+	}
+
+	if len(msgs) == 0 {
+		return nil
+	}
+
+	msg := strings.Join(msgs, ", ")
+	return fmt.Errorf("%s", msg)
+}

platform/dbops/binaries/weaviate-src/test/benchmark_bm25/lib/client.go

@@ -0,0 +1,34 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"net/url"
+
+	client "github.com/weaviate/weaviate-go-client/v5/weaviate"
+)
+
+func ClientFromOrigin(origin string) (*client.Client, error) {
+	parsed, err := url.Parse(origin)
+	if err != nil {
+		return nil, err
+	}
+
+	config := client.Config{
+		Scheme: parsed.Scheme,
+		Host:   parsed.Host,
+	}
+
+	client := client.New(config)
+
+	return client, nil
+}