Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/slow/slow_file_copy_test.go

@@ -0,0 +1,285 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package slow
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	logrustest "github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	enterrors "github.com/weaviate/weaviate/entities/errors"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/acceptance/replication/common"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+type ReplicationTestSuite struct {
+	suite.Suite
+}
+
+func (suite *ReplicationTestSuite) SetupTest() {
+	suite.T().Setenv("TEST_WEAVIATE_IMAGE", "weaviate/test-server")
+}
+
+func TestReplicationTestSuite(t *testing.T) {
+	suite.Run(t, new(ReplicationTestSuite))
+}
+
+func (suite *ReplicationTestSuite) TestReplicaMovementOneWriteExtraSlowFileCopy() {
+	t := suite.T()
+	mainCtx := context.Background()
+	logger, _ := logrustest.NewNullLogger()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithText2VecContextionary().
+		WithWeaviateEnv("WEAVIATE_TEST_COPY_REPLICA_SLEEP", "20s").
+		Start(mainCtx)
+	require.Nil(t, err)
+	defer func() {
+		if err := compose.Terminate(mainCtx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(mainCtx, 10*time.Minute)
+	defer cancel()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+
+	t.Run("stop node 3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ShardingConfig = map[string]interface{}{"desiredCount": 1}
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       1,
+			AsyncEnabled: false,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+		helper.CreateClass(t, paragraphClass)
+	})
+
+	t.Run("restart node 3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+	})
+
+	// Setup client again after restart to avoid HTTP error if client setup to container that now has a changed port
+	helper.SetupClient(compose.GetWeaviate().URI())
+
+	numParagraphsInsertedBeforeStart := 10
+	t.Run("insert paragraphs", func(t *testing.T) {
+		// Create and insert each object individually
+		for i := 0; i < numParagraphsInsertedBeforeStart; i++ {
+			obj := articles.NewParagraph().
+				WithID(strfmt.UUID(uuid.New().String())).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+
+			// Insert the object individually
+			common.CreateObjects(t, compose.GetWeaviate().URI(), []*models.Object{obj})
+		}
+	})
+
+	t.Run("verify that all nodes are running", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			verbose := verbosity.OutputVerbose
+			params := nodes.NewNodesGetClassParams().WithOutput(&verbose)
+			body, clientErr := helper.Client(t).Nodes.NodesGetClass(params, nil)
+			require.NoError(ct, clientErr)
+			require.NotNil(ct, body.Payload)
+
+			resp := body.Payload
+			require.Len(ct, resp.Nodes, 3)
+			for _, n := range resp.Nodes {
+				require.NotNil(ct, n.Status)
+				assert.Equal(ct, "HEALTHY", *n.Status)
+			}
+		}, 15*time.Second, 500*time.Millisecond)
+	})
+
+	var opId strfmt.UUID
+	sourceNode := -1
+	numParagraphsInsertedWhileStarting := 1
+	t.Run("start replica replication to node3 for paragraph", func(t *testing.T) {
+		verbose := verbosity.OutputVerbose
+		params := nodes.NewNodesGetClassParams().WithOutput(&verbose).WithClassName(paragraphClass.Class)
+		body, clientErr := helper.Client(t).Nodes.NodesGetClass(params, nil)
+		require.NoError(t, clientErr)
+		require.NotNil(t, body.Payload)
+		targetNode := "node3"
+		hasFoundNode := false
+		hasFoundShard := false
+
+		for i, node := range body.Payload.Nodes {
+			if node.Name == targetNode {
+				continue
+			}
+
+			if len(node.Shards) >= 1 {
+				hasFoundNode = true
+			} else {
+				continue
+			}
+
+			for _, shard := range node.Shards {
+				if shard.Class != paragraphClass.Class {
+					continue
+				}
+				hasFoundShard = true
+
+				t.Logf("Starting replica replication from %s to %s for shard %s", node.Name, targetNode, shard.Name)
+				// i + 1 because stop/start routine are 1 based not 0
+				sourceNode = i + 1
+				// start replication in parallel with inserting new paragraphs
+				wg := sync.WaitGroup{}
+				wg.Add(1)
+				enterrors.GoWrapper(func() {
+					defer wg.Done()
+					// sleep 20s so that the source node has paused compaction but not resumed yet
+					time.Sleep(20 * time.Second)
+					for i := 0; i < numParagraphsInsertedWhileStarting; i++ {
+						err := createObjectThreadSafe(
+							compose.ContainerURI(sourceNode),
+							paragraphClass.Class,
+							map[string]interface{}{
+								"contents": fmt.Sprintf("paragraph#%d", numParagraphsInsertedBeforeStart+i),
+							},
+							uuid.New().String(),
+							"",
+						)
+						require.NoError(t, err)
+						time.Sleep(time.Millisecond)
+
+					}
+				}, logger)
+
+				wg.Add(1)
+				enterrors.GoWrapper(func() {
+					defer wg.Done()
+					resp, err := helper.Client(t).Replication.Replicate(
+						replication.NewReplicateParams().WithBody(
+							&models.ReplicationReplicateReplicaRequest{
+								Collection: &paragraphClass.Class,
+								SourceNode: &node.Name,
+								TargetNode: &targetNode,
+								Shard:      &shard.Name,
+							},
+						),
+						nil,
+					)
+					require.NoError(t, err)
+					require.Equal(t, http.StatusOK, resp.Code(), "replication replicate operation didn't return 200 OK")
+					opId = *resp.Payload.ID
+				}, logger)
+				wg.Wait()
+			}
+		}
+		require.True(t, hasFoundShard, "could not find shard for class %s", paragraphClass.Class)
+		require.True(t, hasFoundNode, "could not find node with shards for paragraph")
+	})
+
+	// If no node was found fail now
+	if sourceNode == -1 {
+		t.FailNow()
+	}
+
+	// Wait for the replication to finish
+	t.Run("waiting for replication to finish", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			details, err := helper.Client(t).Replication.ReplicationDetails(
+				replication.NewReplicationDetailsParams().WithID(opId), nil,
+			)
+			assert.Nil(t, err, "failed to get replication details %s", err)
+			assert.NotNil(t, details, "expected replication details to be not nil")
+			assert.NotNil(t, details.Payload, "expected replication details payload to be not nil")
+			assert.NotNil(t, details.Payload.Status, "expected replication status to be not nil")
+			assert.Equal(ct, "READY", details.Payload.Status.State, "expected replication status to be READY")
+		}, 360*time.Second, 3*time.Second, "replication operation %s not finished in time", opId)
+	})
+
+	// Kills the original node with the data to ensure we have only one replica available (the new one)
+	t.Run(fmt.Sprintf("stop node %d", sourceNode), func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, sourceNode)
+	})
+
+	t.Run("assert correct number of objects on node3", func(t *testing.T) {
+		numObjectsFound := common.CountObjects(t, compose.ContainerURI(3), paragraphClass.Class)
+		assert.Equal(t, numParagraphsInsertedBeforeStart+numParagraphsInsertedWhileStarting, int(numObjectsFound))
+	})
+}
+
+func createObjectThreadSafe(uri string, class string, properties map[string]interface{}, id string, tenant string) error {
+	// Define the data structure for the request body
+	type Object struct {
+		Class      string                 `json:"class"`
+		Properties map[string]interface{} `json:"properties"`
+		ID         string                 `json:"id"`
+		Tenant     string                 `json:"tenant,omitempty"`
+	}
+
+	// Create an instance of the object with sample data
+	obj := Object{
+		Class:      class,
+		Properties: properties,
+		ID:         id,
+		Tenant:     tenant,
+	}
+
+	// Marshal the object to JSON
+	jsonData, err := json.Marshal(obj)
+	if err != nil {
+		return fmt.Errorf("error marshalling JSON: %w", err)
+	}
+
+	// Create a new POST request
+	req, err := http.NewRequest("POST", "http://"+uri+"/v1/objects", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("error creating request: %w", err)
+	}
+
+	// Set the appropriate headers
+	req.Header.Set("Content-Type", "application/json")
+
+	// Send the request using http.DefaultClient
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("error sending request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Check the response status
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("request failed with status: %s", resp.Status)
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/auth_tests/auth_setup_test.go

@@ -0,0 +1,43 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package auth_tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+const weaviateEndpoint = "WEAVIATE_ENDPOINT"
+
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().
+		WithWeaviateAuth().
+		Start(ctx)
+	if err != nil {
+		panic(errors.Wrapf(err, "cannot start"))
+	}
+
+	os.Setenv(weaviateEndpoint, compose.GetWeaviate().URI())
+	code := m.Run()
+
+	if err := compose.Terminate(ctx); err != nil {
+		panic(errors.Wrapf(err, "cannot terminate"))
+	}
+
+	os.Exit(code)
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/auth_tests/auth_test.go

@@ -0,0 +1,100 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package auth_tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/auth"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/fault"
+	"github.com/weaviate/weaviate/entities/models"
+
+	client "github.com/weaviate/weaviate-go-client/v5/weaviate"
+)
+
+const (
+	wcsUserOnAdmin    = "oidc-test-user@weaviate.io"
+	wcsUserNotOnAdmin = "oidc-test-user2@weaviate.io"
+)
+
+func TestAuthGraphQLUnauthenticated(t *testing.T) {
+	ctx := context.Background()
+	c := client.New(client.Config{Scheme: "http", Host: os.Getenv(weaviateEndpoint)})
+	_, err := c.GraphQL().Raw().WithQuery("{__schema {queryType {fields {name}}}}").Do(ctx)
+	require.NotNil(t, err)
+}
+
+func TestAuthGraphQLValidUserNotOnAdminlist(t *testing.T) {
+	pw := os.Getenv("WCS_DUMMY_CI_PW_2")
+	if pw == "" {
+		t.Skip("No password supplied")
+	}
+
+	ctx := context.Background()
+
+	conf := client.Config{
+		Scheme:     "http",
+		Host:       os.Getenv(weaviateEndpoint),
+		AuthConfig: auth.ResourceOwnerPasswordFlow{Username: wcsUserNotOnAdmin, Password: pw},
+	}
+	c, err := client.NewClient(conf)
+	require.Nil(t, err)
+
+	_, err = c.GraphQL().Raw().WithQuery("{__schema {queryType {fields {name}}}}").Do(ctx)
+	require.NotNil(t, err)
+}
+
+func TestAuthGraphQLValidUser(t *testing.T) {
+	pwAdminUser := os.Getenv("WCS_DUMMY_CI_PW")
+	pwNoAdminUser := os.Getenv("WCS_DUMMY_CI_PW_2")
+	if pwAdminUser == "" || pwNoAdminUser == "" {
+		t.Skip("No password supplied")
+	}
+
+	ctx := context.Background()
+	conf := client.Config{
+		Scheme:     "http",
+		Host:       os.Getenv(weaviateEndpoint),
+		AuthConfig: auth.ResourceOwnerPasswordFlow{Username: wcsUserOnAdmin, Password: pwAdminUser},
+	}
+	c, err := client.NewClient(conf)
+	require.Nil(t, err)
+
+	// add a class so schema is not empty
+	require.Nil(t, c.Schema().AllDeleter().Do(ctx))
+	require.Nil(t, c.Schema().ClassCreator().WithClass(&models.Class{Class: "Pizza"}).Do(ctx))
+
+	t.Run("returns schema without error for admin", func(t *testing.T) {
+		_, err = c.GraphQL().Raw().WithQuery("{__schema {queryType {fields {name}}}}").Do(ctx)
+		require.Nil(t, err)
+	})
+
+	t.Run("returns auth error for non-admin", func(t *testing.T) {
+		conf2 := client.Config{
+			Scheme:     "http",
+			Host:       os.Getenv(weaviateEndpoint),
+			AuthConfig: auth.ResourceOwnerPasswordFlow{Username: wcsUserNotOnAdmin, Password: pwNoAdminUser},
+		}
+		cNoAdmin, err := client.NewClient(conf2)
+		require.Nil(t, err)
+
+		_, err = cNoAdmin.GraphQL().Raw().WithQuery("{__schema {queryType {fields {name}}}}").Do(ctx)
+		require.NotNil(t, err)
+		wErr, ok := err.(*fault.WeaviateClientError)
+		require.True(t, ok)
+
+		require.Contains(t, wErr.DerivedFromError.Error(), "forbidden")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/compression/compression_test.go

@@ -0,0 +1,368 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package compression_test
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestCompression_AdaptSegments(t *testing.T) {
+	type dimensionTestCase struct {
+		vectors [][]float32
+	}
+	type vectorTypeTestCase struct {
+		name          string
+		createClassFn func(t *testing.T, client *wvt.Client, className string) *models.Class
+		populateFn    func(t *testing.T, client *wvt.Client, className string, vectors [][]float32)
+		compressFn    func(t *testing.T, client *wvt.Client, class *models.Class)
+	}
+
+	ctx := context.Background()
+	className := "Compressed"
+	vectorsCount := 1000
+
+	dimensionTestCases := []dimensionTestCase{
+		{vectors: randomVecs(vectorsCount, 768)},
+		{vectors: randomVecs(vectorsCount, 4)},
+	}
+
+	t.Run("async indexing", func(t *testing.T) {
+		vectorTypeTestCases := []vectorTypeTestCase{
+			{
+				name:          "legacy vector",
+				createClassFn: createClassLegacyVector,
+				populateFn:    populateLegacyVector,
+				compressFn:    compressLegacyVectorAsync,
+			},
+			{
+				name:          "target vectors",
+				createClassFn: createClassTargetVectors,
+				populateFn:    populateTargetVectors,
+				compressFn:    compressTargetVectorsAsync,
+			},
+		}
+
+		compose, err := docker.New().
+			WithWeaviate().
+			WithWeaviateEnv("ASYNC_INDEXING", "true").
+			WithWeaviateEnv("ASYNC_INDEXING_STALE_TIMEOUT", "1s").
+			Start(ctx)
+		require.NoError(t, err)
+		defer func() {
+			require.NoError(t, compose.Terminate(ctx))
+		}()
+
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: compose.GetWeaviate().URI()})
+		require.NoError(t, err)
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(ctx)
+			require.NoError(t, err)
+		}
+
+		for _, dtc := range dimensionTestCases {
+			t.Run(fmt.Sprintf("dimensions %d", len(dtc.vectors[0])), func(t *testing.T) {
+				for _, vttc := range vectorTypeTestCases {
+					t.Run(vttc.name, func(t *testing.T) {
+						defer cleanup()
+
+						var class *models.Class
+
+						t.Run("create class", func(t *testing.T) {
+							class = vttc.createClassFn(t, client, className)
+						})
+
+						t.Run("compress", func(t *testing.T) {
+							vttc.compressFn(t, client, class)
+						})
+
+						t.Run("populate", func(t *testing.T) {
+							vttc.populateFn(t, client, className, dtc.vectors)
+						})
+
+						t.Run("check eventually compressed", func(t *testing.T) {
+							checkEventuallyCompressed(t, client, className)
+						})
+					})
+				}
+			})
+		}
+	})
+
+	t.Run("sync indexing", func(t *testing.T) {
+		vectorTypeTestCases := []vectorTypeTestCase{
+			{
+				name:          "legacy vector",
+				createClassFn: createClassLegacyVector,
+				populateFn:    populateLegacyVector,
+				compressFn:    compressLegacyVectorSync,
+			},
+			{
+				name:          "target vectors",
+				createClassFn: createClassTargetVectors,
+				populateFn:    populateTargetVectors,
+				compressFn:    compressTargetVectorsSync,
+			},
+		}
+
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+		require.NoError(t, err)
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(ctx)
+			require.NoError(t, err)
+		}
+
+		for _, dtc := range dimensionTestCases {
+			t.Run(fmt.Sprintf("dimensions %d", len(dtc.vectors[0])), func(t *testing.T) {
+				for _, vttc := range vectorTypeTestCases {
+					t.Run(vttc.name, func(t *testing.T) {
+						defer cleanup()
+
+						var class *models.Class
+
+						t.Run("create class", func(t *testing.T) {
+							class = vttc.createClassFn(t, client, className)
+						})
+
+						t.Run("populate", func(t *testing.T) {
+							vttc.populateFn(t, client, className, dtc.vectors)
+						})
+
+						t.Run("compress", func(t *testing.T) {
+							vttc.compressFn(t, client, class)
+						})
+
+						t.Run("check eventually compressed", func(t *testing.T) {
+							checkEventuallyCompressed(t, client, className)
+						})
+					})
+				}
+			})
+		}
+	})
+}
+
+func createClassLegacyVector(t *testing.T, client *wvt.Client, className string) *models.Class {
+	class := &models.Class{
+		Class: className,
+		Properties: []*models.Property{{
+			Name:     "int",
+			DataType: schema.DataTypeInt.PropString(),
+		}},
+		Vectorizer:        "none",
+		VectorIndexConfig: hnswCompressVectorIndexConfig(),
+	}
+
+	createClass(t, client, class)
+	return class
+}
+
+func createClassTargetVectors(t *testing.T, client *wvt.Client, className string) *models.Class {
+	class := &models.Class{
+		Class: className,
+		Properties: []*models.Property{{
+			Name:     "int",
+			DataType: schema.DataTypeInt.PropString(),
+		}},
+		VectorConfig: map[string]models.VectorConfig{
+			"vectorFlat": {
+				VectorIndexType: "flat",
+				Vectorizer: map[string]interface{}{
+					"none": struct{}{},
+				},
+			},
+			"vectorHnswCompress": {
+				VectorIndexType: "hnsw",
+				Vectorizer: map[string]interface{}{
+					"none": struct{}{},
+				},
+				VectorIndexConfig: hnswCompressVectorIndexConfig(),
+			},
+		},
+	}
+
+	err := client.Schema().ClassCreator().
+		WithClass(class).
+		Do(context.Background())
+	if err != nil {
+		require.NoError(t, err)
+	}
+
+	return class
+}
+
+func createClass(t *testing.T, client *wvt.Client, class *models.Class) {
+	err := client.Schema().ClassCreator().
+		WithClass(class).
+		Do(context.Background())
+	require.NoError(t, err)
+}
+
+func hnswCompressVectorIndexConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"maxConnections":        32,
+		"efConstruction":        64,
+		"ef":                    32,
+		"vectorCacheMaxObjects": 10e12,
+		"distance":              "l2-squared",
+		"pq": map[string]interface{}{
+			"enabled": true,
+			"encoder": map[string]interface{}{
+				"distribution": hnsw.PQEncoderDistributionNormal,
+				"type":         hnsw.PQEncoderTypeKMeans,
+			},
+		},
+	}
+}
+
+func populateLegacyVector(t *testing.T, client *wvt.Client, className string, vectors [][]float32) {
+	objects := make([]*models.Object, len(vectors))
+	for i, vector := range vectors {
+		objects[i] = &models.Object{
+			Class: className,
+			Properties: map[string]interface{}{
+				"int": i,
+			},
+			Vector: vector,
+		}
+	}
+
+	populate(t, client, objects)
+}
+
+func populateTargetVectors(t *testing.T, client *wvt.Client, className string, vectors [][]float32) {
+	objects := make([]*models.Object, len(vectors))
+	for i, vector := range vectors {
+		objects[i] = &models.Object{
+			Class: className,
+			Properties: map[string]interface{}{
+				"int": i,
+			},
+			Vectors: models.Vectors{
+				"vectorFlat":         vector,
+				"vectorHnswCompress": vector,
+			},
+		}
+	}
+
+	populate(t, client, objects)
+}
+
+func populate(t *testing.T, client *wvt.Client, objects []*models.Object) {
+	resps, err := client.Batch().ObjectsBatcher().
+		WithObjects(objects...).
+		Do(context.Background())
+	require.NoError(t, err)
+	require.Len(t, resps, len(objects))
+	for _, resp := range resps {
+		require.NotNil(t, resp.Result.Status)
+		require.Equal(t, models.ObjectsGetResponseAO2ResultStatusSUCCESS, *resp.Result.Status)
+	}
+}
+
+func compressLegacyVectorAsync(t *testing.T, client *wvt.Client, class *models.Class) {
+	updateConfigAsync(class.VectorIndexConfig.(map[string]interface{})["pq"].(map[string]interface{}))
+	compress(t, client, class)
+}
+
+func compressLegacyVectorSync(t *testing.T, client *wvt.Client, class *models.Class) {
+	updateConfigSync(class.VectorIndexConfig.(map[string]interface{})["pq"].(map[string]interface{}))
+	compress(t, client, class)
+}
+
+func compressTargetVectorsAsync(t *testing.T, client *wvt.Client, class *models.Class) {
+	updateConfigAsync(class.VectorConfig["vectorHnswCompress"].
+		VectorIndexConfig.(map[string]interface{})["pq"].(map[string]interface{}))
+	compress(t, client, class)
+}
+
+func compressTargetVectorsSync(t *testing.T, client *wvt.Client, class *models.Class) {
+	updateConfigSync(class.VectorConfig["vectorHnswCompress"].
+		VectorIndexConfig.(map[string]interface{})["pq"].(map[string]interface{}))
+	compress(t, client, class)
+}
+
+func updateConfigAsync(pq map[string]interface{}) {
+	pq["segments"] = 0
+	pq["centroids"] = 256
+	pq["trainingLimit"] = 999
+}
+
+func updateConfigSync(pq map[string]interface{}) {
+	pq["segments"] = 0
+	pq["centroids"] = 256
+}
+
+func compress(t *testing.T, client *wvt.Client, class *models.Class) {
+	err := client.Schema().ClassUpdater().
+		WithClass(class).
+		Do(context.Background())
+	require.NoError(t, err)
+}
+
+func checkEventuallyCompressed(t *testing.T, client *wvt.Client, className string) {
+	ctx := context.Background()
+	timeout := 15 * time.Minute
+	interval := 1 * time.Second
+
+	var compressed bool
+	end := time.Now().Add(timeout)
+	for time.Now().Before(end) {
+		resp, err := client.Cluster().NodesStatusGetter().
+			WithClass(className).
+			WithOutput("verbose").
+			Do(ctx)
+		require.NoError(t, err)
+		require.NotNil(t, resp)
+		require.Len(t, resp.Nodes, 1)
+		require.Len(t, resp.Nodes[0].Shards, 1)
+
+		compressed = resp.Nodes[0].Shards[0].Compressed
+		fmt.Printf("  ==> compressed %v\n", compressed)
+		if compressed {
+			break
+		}
+		time.Sleep(interval)
+	}
+
+	require.True(t, compressed)
+}
+
+func randomVecs(count int, dimensions int) [][]float32 {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	vectors := make([][]float32, count)
+	for i := range vectors {
+		vectors[i] = genVector(r, dimensions)
+	}
+	return vectors
+}
+
+func genVector(r *rand.Rand, dimensions int) []float32 {
+	vector := make([]float32, dimensions)
+	for i := range vector {
+		// Some distances like dot could produce negative values when the vectors have negative values
+		// This change will not affect anything when using a distance like l2, but will cover some bugs
+		// when using distances like dot
+		vector[i] = r.Float32()*2 - 1
+	}
+	return vector
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/filters_tests/contains_test.go

@@ -0,0 +1,1049 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package filters_tests
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	acceptance_with_go_client "acceptance_tests_with_client"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "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/entities/schema"
+)
+
+func testContains(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		className := "WhereTest"
+		id1 := "00000000-0000-0000-0000-000000000001"
+		id2 := "00000000-0000-0000-0000-000000000002"
+		id3 := "00000000-0000-0000-0000-000000000003"
+		ids := []string{id1, id2, id3}
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("create class", func(t *testing.T) {
+			cleanup()
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name:     "color",
+						DataType: schema.DataTypeText.PropString(),
+					},
+					{
+						Name:     "colors",
+						DataType: schema.DataTypeTextArray.PropString(),
+					},
+					{
+						Name:     "author",
+						DataType: schema.DataTypeString.PropString(),
+					},
+					{
+						Name:     "authors",
+						DataType: schema.DataTypeStringArray.PropString(),
+					},
+					{
+						Name:     "number",
+						DataType: schema.DataTypeNumber.PropString(),
+					},
+					{
+						Name:     "numbers",
+						DataType: schema.DataTypeNumberArray.PropString(),
+					},
+					{
+						Name:     "int",
+						DataType: schema.DataTypeInt.PropString(),
+					},
+					{
+						Name:     "ints",
+						DataType: schema.DataTypeIntArray.PropString(),
+					},
+					{
+						Name:     "date",
+						DataType: schema.DataTypeDate.PropString(),
+					},
+					{
+						Name:     "dates",
+						DataType: schema.DataTypeDateArray.PropString(),
+					},
+					{
+						Name:     "bool",
+						DataType: schema.DataTypeBoolean.PropString(),
+					},
+					{
+						Name:     "bools",
+						DataType: schema.DataTypeBooleanArray.PropString(),
+					},
+					{
+						Name:     "uuid",
+						DataType: schema.DataTypeUUID.PropString(),
+					},
+					{
+						Name:     "uuids",
+						DataType: schema.DataTypeUUIDArray.PropString(),
+					},
+				},
+			}
+			err := client.Schema().ClassCreator().WithClass(class).Do(context.TODO())
+			require.Nil(t, err)
+			// Give time for the schema to replicate and graphql to rebuild it for it's queries
+			time.Sleep(3 * time.Second)
+		})
+
+		t.Run("where with bm25 without data", func(t *testing.T) {
+			mustGetTime := func(date string) time.Time {
+				result, err := time.Parse(time.RFC3339Nano, date)
+				if err != nil {
+					panic(fmt.Sprintf("can't parse date: %v", date))
+				}
+				return result
+			}
+			tests := []struct {
+				name     string
+				where    *filters.WhereBuilder
+				property string
+			}{
+				// Contains operator with array types
+				{
+					name: "contains any authors with string array",
+					where: filters.Where().
+						WithPath([]string{"authors"}).
+						WithOperator(filters.ContainsAny).
+						WithValueString("John", "Jenny", "Joseph"),
+					property: "authors",
+				},
+				{
+					name: "contains any colors with text array",
+					where: filters.Where().
+						WithPath([]string{"colors"}).
+						WithOperator(filters.ContainsAny).
+						WithValueText("red", "blue", "green"),
+					property: "colors",
+				},
+				{
+					name: "contains any numbers with number array",
+					where: filters.Where().
+						WithPath([]string{"numbers"}).
+						WithOperator(filters.ContainsAny).
+						WithValueNumber(1.1, 2.2, 3.3),
+					property: "numbers",
+				},
+				{
+					name: "contains any ints with int array",
+					where: filters.Where().
+						WithPath([]string{"ints"}).
+						WithOperator(filters.ContainsAny).
+						WithValueInt(1, 2, 3),
+					property: "ints",
+				},
+				{
+					name: "contains any bools with bool array",
+					where: filters.Where().
+						WithPath([]string{"bools"}).
+						WithOperator(filters.ContainsAny).
+						WithValueBoolean(true, false),
+					property: "bools",
+				},
+				{
+					name: "contains any uuids with uuid array",
+					where: filters.Where().
+						WithPath([]string{"uuids"}).
+						WithOperator(filters.ContainsAny).
+						WithValueText(id1, id2, id3),
+					property: "uuids",
+				},
+				{
+					name: "contains any dates with dates array",
+					where: filters.Where().
+						WithPath([]string{"dates"}).
+						WithOperator(filters.ContainsAny).
+						WithValueDate(
+							mustGetTime("2009-11-01T23:00:00Z"), mustGetTime("2009-11-02T23:00:00Z"), mustGetTime("2009-11-03T23:00:00Z"),
+						),
+					property: "dates",
+				},
+				// Contains operator with primitives
+				{
+					name: "contains any author with string",
+					where: filters.Where().
+						WithPath([]string{"author"}).
+						WithOperator(filters.ContainsAny).
+						WithValueString("John", "Jenny", "Joseph"),
+					property: "author",
+				},
+				{
+					name: "contains any color with text",
+					where: filters.Where().
+						WithPath([]string{"color"}).
+						WithOperator(filters.ContainsAny).
+						WithValueText("red", "blue", "green"),
+					property: "color",
+				},
+				{
+					name: "contains any number with number",
+					where: filters.Where().
+						WithPath([]string{"number"}).
+						WithOperator(filters.ContainsAny).
+						WithValueNumber(1.1, 2.2, 3.3),
+					property: "number",
+				},
+				{
+					name: "contains any int with int",
+					where: filters.Where().
+						WithPath([]string{"int"}).
+						WithOperator(filters.ContainsAny).
+						WithValueInt(1, 2, 3),
+					property: "int",
+				},
+				{
+					name: "contains any bool with bool",
+					where: filters.Where().
+						WithPath([]string{"bool"}).
+						WithOperator(filters.ContainsAny).
+						WithValueBoolean(true, false, true),
+					property: "bool",
+				},
+				{
+					name: "contains any uuid with uuid",
+					where: filters.Where().
+						WithPath([]string{"uuid"}).
+						WithOperator(filters.ContainsAny).
+						WithValueText(id1, id2, id3),
+					property: "uuid",
+				},
+				{
+					name: "contains any uuid with id",
+					where: filters.Where().
+						WithPath([]string{"id"}).
+						WithOperator(filters.ContainsAny).
+						WithValueText(id1, id2, id3),
+					property: "uuid",
+				},
+				{
+					name: "contains any date with date",
+					where: filters.Where().
+						WithPath([]string{"date"}).
+						WithOperator(filters.ContainsAny).
+						WithValueDate(
+							mustGetTime("2009-11-01T23:00:00Z"), mustGetTime("2009-11-02T23:00:00Z"), mustGetTime("2009-11-03T23:00:00Z"),
+						),
+					property: "date",
+				},
+			}
+			for _, tt := range tests {
+				t.Run(tt.name, func(t *testing.T) {
+					fields := []graphql.Field{
+						{Name: tt.property},
+						{Name: "_additional", Fields: []graphql.Field{{Name: "id"}}},
+					}
+					resp, err := client.GraphQL().Get().
+						WithClassName(className).
+						WithWhere(tt.where).
+						WithBM25(client.GraphQL().
+							Bm25ArgBuilder().
+							WithQuery(tt.property),
+						).
+						WithFields(fields...).
+						Do(context.TODO())
+					require.Nil(t, err)
+					require.Empty(t, resp.Errors)
+				})
+			}
+		})
+
+		t.Run("with data", func(t *testing.T) {
+			t.Run("insert data", func(t *testing.T) {
+				authors := []string{"John", "Jenny", "Joseph"}
+				authorsArray := [][]string{
+					{"John", "Jenny", "Joseph"},
+					{"John", "Jenny"},
+					{"John"},
+				}
+				colors := []string{"red", "blue", "green"}
+				colorsArray := [][]string{
+					{"red", "blue", "green"},
+					{"red", "blue"},
+					{"red"},
+				}
+				numbers := []float64{1.1, 2.2, 3.3}
+				numbersArray := [][]float64{
+					{1.1, 2.2, 3.3},
+					{1.1, 2.2},
+					{1.1},
+				}
+				ints := []int64{1, 2, 3}
+				intsArray := [][]int64{
+					{1, 2, 3},
+					{1, 2},
+					{1},
+				}
+				uuids := []string{id1, id2, id3}
+				uuidsArray := [][]string{
+					{id1, id2, id3},
+					{id1, id2},
+					{id1},
+				}
+				dates := []string{"2009-11-01T23:00:00Z", "2009-11-02T23:00:00Z", "2009-11-03T23:00:00Z"}
+				datesArray := [][]string{
+					{"2009-11-01T23:00:00Z", "2009-11-02T23:00:00Z", "2009-11-03T23:00:00Z"},
+					{"2009-11-01T23:00:00Z", "2009-11-02T23:00:00Z"},
+					{"2009-11-01T23:00:00Z"},
+				}
+				bools := []bool{true, false, true}
+				boolsArray := [][]bool{
+					{true, false, true},
+					{true, false},
+					{true},
+				}
+				for i, id := range ids {
+					_, err := client.Data().Creator().
+						WithClassName(className).
+						WithID(id).
+						WithProperties(map[string]interface{}{
+							"color":   colors[i],
+							"colors":  colorsArray[i],
+							"author":  authors[i],
+							"authors": authorsArray[i],
+							"number":  numbers[i],
+							"numbers": numbersArray[i],
+							"int":     ints[i],
+							"ints":    intsArray[i],
+							"uuid":    uuids[i],
+							"uuids":   uuidsArray[i],
+							"date":    dates[i],
+							"dates":   datesArray[i],
+							"bool":    bools[i],
+							"bools":   boolsArray[i],
+						}).
+						Do(context.TODO())
+					require.Nil(t, err)
+				}
+			})
+
+			t.Run("where", func(t *testing.T) {
+				mustGetTime := func(date string) time.Time {
+					result, err := time.Parse(time.RFC3339Nano, date)
+					if err != nil {
+						panic(fmt.Sprintf("can't parse date: %v", date))
+					}
+					return result
+				}
+				tests := []struct {
+					name        string
+					where       *filters.WhereBuilder
+					property    string
+					nearText    *graphql.NearTextArgumentBuilder
+					expectedIds []string
+				}{
+					// Contains operator with array types
+					{
+						name: "contains all authors with string array",
+						where: filters.Where().
+							WithPath([]string{"authors"}).
+							WithOperator(filters.ContainsAll).
+							WithValueString("John", "Jenny", "Joseph"),
+						property:    "authors",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains any authors with string array",
+						where: filters.Where().
+							WithPath([]string{"authors"}).
+							WithOperator(filters.ContainsAny).
+							WithValueString("John", "Jenny", "Joseph"),
+						property:    "authors",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains none authors with string array",
+						where: filters.Where().
+							WithPath([]string{"authors"}).
+							WithOperator(filters.ContainsNone).
+							WithValueString("Joseph", "Missing"),
+						property:    "authors",
+						expectedIds: []string{id2, id3},
+					},
+					{
+						name: "contains all colors with text array",
+						where: filters.Where().
+							WithPath([]string{"colors"}).
+							WithOperator(filters.ContainsAll).
+							WithValueText("red", "blue", "green"),
+						property:    "colors",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains any colors with text array",
+						where: filters.Where().
+							WithPath([]string{"colors"}).
+							WithOperator(filters.ContainsAny).
+							WithValueText("red", "blue", "green"),
+						property:    "colors",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains none colors with text array",
+						where: filters.Where().
+							WithPath([]string{"colors"}).
+							WithOperator(filters.ContainsNone).
+							WithValueText("green", "missing"),
+						property:    "colors",
+						expectedIds: []string{id2, id3},
+					},
+					{
+						name: "contains all numbers with number array",
+						where: filters.Where().
+							WithPath([]string{"numbers"}).
+							WithOperator(filters.ContainsAll).
+							WithValueNumber(1.1, 2.2, 3.3),
+						property:    "numbers",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains any numbers with number array",
+						where: filters.Where().
+							WithPath([]string{"numbers"}).
+							WithOperator(filters.ContainsAny).
+							WithValueNumber(1.1, 2.2, 3.3),
+						property:    "numbers",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains none numbers with number array",
+						where: filters.Where().
+							WithPath([]string{"numbers"}).
+							WithOperator(filters.ContainsNone).
+							WithValueNumber(3.3, 0),
+						property:    "numbers",
+						expectedIds: []string{id2, id3},
+					},
+					{
+						name: "contains all ints with int array",
+						where: filters.Where().
+							WithPath([]string{"ints"}).
+							WithOperator(filters.ContainsAll).
+							WithValueInt(1, 2, 3),
+						property:    "ints",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains any ints with int array",
+						where: filters.Where().
+							WithPath([]string{"ints"}).
+							WithOperator(filters.ContainsAny).
+							WithValueInt(1, 2, 3),
+						property:    "ints",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains none ints with int array",
+						where: filters.Where().
+							WithPath([]string{"ints"}).
+							WithOperator(filters.ContainsNone).
+							WithValueInt(3, 0),
+						property:    "ints",
+						expectedIds: []string{id2, id3},
+					},
+					{
+						name: "contains all bools with bool array",
+						where: filters.Where().
+							WithPath([]string{"bools"}).
+							WithOperator(filters.ContainsAll).
+							WithValueBoolean(true, false, true),
+						property:    "bools",
+						expectedIds: []string{id1, id2},
+					},
+					{
+						name: "contains any bools with bool array",
+						where: filters.Where().
+							WithPath([]string{"bools"}).
+							WithOperator(filters.ContainsAny).
+							WithValueBoolean(true, false),
+						property:    "bools",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains none bools with bool array",
+						where: filters.Where().
+							WithPath([]string{"bools"}).
+							WithOperator(filters.ContainsNone).
+							WithValueBoolean(false),
+						property:    "bools",
+						expectedIds: []string{id3},
+					},
+					{
+						name: "contains all uuids with uuid array",
+						where: filters.Where().
+							WithPath([]string{"uuids"}).
+							WithOperator(filters.ContainsAll).
+							WithValueText(id1, id2, id3),
+						property:    "uuids",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains any uuids with uuid array",
+						where: filters.Where().
+							WithPath([]string{"uuids"}).
+							WithOperator(filters.ContainsAny).
+							WithValueText(id1, id2, id3),
+						property:    "uuids",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains none uuids with uuid array",
+						where: filters.Where().
+							WithPath([]string{"uuids"}).
+							WithOperator(filters.ContainsNone).
+							WithValueText(id3, "FFFFFFFF-FFFF-0000-0000-000000000000"),
+						property:    "uuids",
+						expectedIds: []string{id2, id3},
+					},
+					{
+						name: "contains all dates with dates array",
+						where: filters.Where().
+							WithPath([]string{"dates"}).
+							WithOperator(filters.ContainsAll).
+							WithValueDate(
+								mustGetTime("2009-11-01T23:00:00Z"),
+								mustGetTime("2009-11-02T23:00:00Z"),
+								mustGetTime("2009-11-03T23:00:00Z"),
+							),
+						property:    "dates",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains any dates with dates array",
+						where: filters.Where().
+							WithPath([]string{"dates"}).
+							WithOperator(filters.ContainsAny).
+							WithValueDate(
+								mustGetTime("2009-11-01T23:00:00Z"),
+								mustGetTime("2009-11-02T23:00:00Z"),
+								mustGetTime("2009-11-03T23:00:00Z"),
+							),
+						property:    "dates",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains none dates with dates array",
+						where: filters.Where().
+							WithPath([]string{"dates"}).
+							WithOperator(filters.ContainsNone).
+							WithValueDate(
+								mustGetTime("2009-11-03T23:00:00Z"),
+								mustGetTime("1970-01-01T00:00:00Z"),
+							),
+						property:    "dates",
+						expectedIds: []string{id2, id3},
+					},
+					{
+						name: "complex contains all ints and all numbers with AND on int array",
+						where: filters.Where().
+							WithOperator(filters.And).
+							WithOperands([]*filters.WhereBuilder{
+								filters.Where().
+									WithPath([]string{"numbers"}).
+									WithOperator(filters.ContainsAll).
+									WithValueNumber(1.1, 2.2, 3.3),
+								filters.Where().
+									WithPath([]string{"ints"}).
+									WithOperator(filters.ContainsAll).
+									WithValueInt(1, 2, 3),
+							}),
+						property:    "ints",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "complex contains any ints and all numbers and none texts with OR",
+						where: filters.Where().
+							WithOperator(filters.Or).
+							WithOperands([]*filters.WhereBuilder{
+								filters.Where().
+									WithPath([]string{"numbers"}).
+									WithOperator(filters.ContainsAll).
+									WithValueNumber(1.1, 2.2, 3.3),
+								filters.Where().
+									WithPath([]string{"ints"}).
+									WithOperator(filters.ContainsAny).
+									WithValueInt(3),
+								filters.Where().
+									WithPath([]string{"authors"}).
+									WithOperator(filters.ContainsNone).
+									WithValueString("Jenny", "Missing"),
+							}),
+						property:    "ints",
+						expectedIds: []string{id1, id3},
+					},
+					// Contains operator with primitives
+					{
+						name: "contains any author with string",
+						where: filters.Where().
+							WithPath([]string{"author"}).
+							WithOperator(filters.ContainsAny).
+							WithValueString("John", "Jenny", "Joseph"),
+						property:    "author",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains any color with text",
+						where: filters.Where().
+							WithPath([]string{"color"}).
+							WithOperator(filters.ContainsAny).
+							WithValueText("red", "blue", "green"),
+						property:    "color",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains any number with number",
+						where: filters.Where().
+							WithPath([]string{"number"}).
+							WithOperator(filters.ContainsAny).
+							WithValueNumber(1.1, 2.2, 3.3),
+						property:    "number",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains any int with int",
+						where: filters.Where().
+							WithPath([]string{"int"}).
+							WithOperator(filters.ContainsAny).
+							WithValueInt(1, 2, 3),
+						property:    "int",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains any bool with bool",
+						where: filters.Where().
+							WithPath([]string{"bool"}).
+							WithOperator(filters.ContainsAny).
+							WithValueBoolean(true, false, true),
+						property:    "bool",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains any uuid with uuid",
+						where: filters.Where().
+							WithPath([]string{"uuid"}).
+							WithOperator(filters.ContainsAny).
+							WithValueText(id1, id2, id3),
+						property:    "uuid",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains any uuid with id",
+						where: filters.Where().
+							WithPath([]string{"id"}).
+							WithOperator(filters.ContainsAny).
+							WithValueText(id1, id2, id3),
+						property:    "uuid",
+						expectedIds: []string{id1, id2, id3},
+					},
+					{
+						name: "contains any date with date",
+						where: filters.Where().
+							WithPath([]string{"date"}).
+							WithOperator(filters.ContainsAny).
+							WithValueDate(
+								mustGetTime("2009-11-01T23:00:00Z"), mustGetTime("2009-11-02T23:00:00Z"), mustGetTime("2009-11-03T23:00:00Z"),
+							),
+						property:    "date",
+						expectedIds: []string{id1, id2, id3},
+					},
+
+					{
+						name: "contains all author with string",
+						where: filters.Where().
+							WithPath([]string{"author"}).
+							WithOperator(filters.ContainsAll).
+							WithValueString("Jenny"),
+						property:    "author",
+						expectedIds: []string{id2},
+					},
+					{
+						name: "contains all color with text",
+						where: filters.Where().
+							WithPath([]string{"color"}).
+							WithOperator(filters.ContainsAll).
+							WithValueText("blue"),
+						property:    "color",
+						expectedIds: []string{id2},
+					},
+					{
+						name: "contains all number with number",
+						where: filters.Where().
+							WithPath([]string{"number"}).
+							WithOperator(filters.ContainsAll).
+							WithValueNumber(2.2),
+						property:    "number",
+						expectedIds: []string{id2},
+					},
+					{
+						name: "contains all int with int",
+						where: filters.Where().
+							WithPath([]string{"int"}).
+							WithOperator(filters.ContainsAll).
+							WithValueInt(2),
+						property:    "int",
+						expectedIds: []string{id2},
+					},
+					{
+						name: "contains all bool with bool",
+						where: filters.Where().
+							WithPath([]string{"bool"}).
+							WithOperator(filters.ContainsAll).
+							WithValueBoolean(false),
+						property:    "bool",
+						expectedIds: []string{id2},
+					},
+					{
+						name: "contains all uuid with uuid",
+						where: filters.Where().
+							WithPath([]string{"uuid"}).
+							WithOperator(filters.ContainsAll).
+							WithValueText(id2),
+						property:    "uuid",
+						expectedIds: []string{id2},
+					},
+					{
+						name: "contains all date with date",
+						where: filters.Where().
+							WithPath([]string{"date"}).
+							WithOperator(filters.ContainsAll).
+							WithValueDate(mustGetTime("2009-11-02T23:00:00Z")),
+						property:    "date",
+						expectedIds: []string{id2},
+					},
+
+					{
+						name: "contains none author with string",
+						where: filters.Where().
+							WithPath([]string{"author"}).
+							WithOperator(filters.ContainsNone).
+							WithValueString("Jenny", "Joseph"),
+						property:    "author",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains none color with text",
+						where: filters.Where().
+							WithPath([]string{"color"}).
+							WithOperator(filters.ContainsNone).
+							WithValueText("blue", "green"),
+						property:    "color",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains none number with number",
+						where: filters.Where().
+							WithPath([]string{"number"}).
+							WithOperator(filters.ContainsNone).
+							WithValueNumber(2.2, 3.3),
+						property:    "number",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains none int with int",
+						where: filters.Where().
+							WithPath([]string{"int"}).
+							WithOperator(filters.ContainsNone).
+							WithValueInt(2, 3),
+						property:    "int",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains none bool with bool",
+						where: filters.Where().
+							WithPath([]string{"bool"}).
+							WithOperator(filters.ContainsNone).
+							WithValueBoolean(false),
+						property:    "bool",
+						expectedIds: []string{id1, id3},
+					},
+					{
+						name: "contains none uuid with uuid",
+						where: filters.Where().
+							WithPath([]string{"uuid"}).
+							WithOperator(filters.ContainsNone).
+							WithValueText(id2, id3),
+						property:    "uuid",
+						expectedIds: []string{id1},
+					},
+					{
+						name: "contains none date with date",
+						where: filters.Where().
+							WithPath([]string{"date"}).
+							WithOperator(filters.ContainsNone).
+							WithValueDate(
+								mustGetTime("2009-11-02T23:00:00Z"),
+								mustGetTime("2009-11-03T23:00:00Z"),
+							),
+						property:    "date",
+						expectedIds: []string{id1},
+					},
+
+					{
+						name: "contains all authors with string array and nearText",
+						where: filters.Where().
+							WithPath([]string{"authors"}).
+							WithOperator(filters.ContainsAll).
+							WithValueString("John", "Jenny", "Joseph"),
+						property: "authors",
+						nearText: client.GraphQL().NearTextArgBuilder().
+							WithConcepts([]string{"John"}),
+						expectedIds: []string{id1},
+					},
+				}
+				for _, tt := range tests {
+					t.Run(tt.name, func(t *testing.T) {
+						fields := []graphql.Field{
+							{Name: tt.property},
+							{Name: "_additional", Fields: []graphql.Field{{Name: "id"}}},
+						}
+						resp, err := client.GraphQL().Get().
+							WithClassName(className).
+							WithWhere(tt.where).
+							WithFields(fields...).
+							WithNearText(tt.nearText).
+							Do(context.TODO())
+						require.Nil(t, err)
+						resultIds := acceptance_with_go_client.GetIds(t, resp, className)
+						assert.Len(t, resultIds, len(tt.expectedIds))
+						assert.ElementsMatch(t, resultIds, tt.expectedIds)
+					})
+				}
+			})
+		})
+	}
+}
+
+func testContainsMovies(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.NoError(t, err)
+
+		collectionName := "Movies"
+		movies := []struct {
+			id        string
+			title     string
+			director  string
+			languages []string
+		}{
+			{
+				id:        "00000000-0000-0000-0000-000000000000",
+				title:     "Braveheart",
+				director:  "Mel Gibson",
+				languages: []string{"English", "French", "Latin", "Scottish Gaelic"},
+			},
+			{
+				id:        "00000000-0000-0000-0000-000000000001",
+				title:     "A Prophet",
+				director:  "Mel Gibson",
+				languages: []string{"French", "Arabic", "Corsican"},
+			},
+			{
+				id:        "00000000-0000-0000-0000-000000000002",
+				title:     "Avatar",
+				director:  "James Cameron",
+				languages: []string{"Portugese", "Czech", "Romanian", "German"},
+			},
+			{
+				id:        "00000000-0000-0000-0000-000000000003",
+				title:     "Spectre",
+				director:  "Sam Mendes",
+				languages: []string{"Spanish", "Finnish", "Polish"},
+			},
+			{
+				id:        "00000000-0000-0000-0000-000000000004",
+				title:     "The Dark Knight Rises",
+				director:  "Christopher Nolan",
+				languages: []string{"English", "German", "Dutch", "Swedish"},
+			},
+			{
+				id:        "00000000-0000-0000-0000-000000000005",
+				title:     "Incendies",
+				director:  "Denis Villeneuve",
+				languages: []string{"English", "French", "Polish", "Arabic"},
+			},
+		}
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+		defer cleanup()
+
+		t.Run("create and populate collection", func(t *testing.T) {
+			cleanup()
+			class := &models.Class{
+				Class: collectionName,
+				Properties: []*models.Property{
+					{
+						Name:         "title",
+						DataType:     schema.DataTypeText.PropString(),
+						Tokenization: models.PropertyTokenizationField,
+					},
+					{
+						Name:         "director",
+						DataType:     schema.DataTypeText.PropString(),
+						Tokenization: models.PropertyTokenizationField,
+					},
+					{
+						Name:         "languages",
+						DataType:     schema.DataTypeTextArray.PropString(),
+						Tokenization: models.PropertyTokenizationField,
+					},
+				},
+			}
+			err := client.Schema().ClassCreator().WithClass(class).Do(context.Background())
+			require.NoError(t, err)
+			// Give time for the schema to replicate and graphql to rebuild it for it's queries
+			time.Sleep(3 * time.Second)
+
+			for i := range movies {
+				_, err := client.Data().Creator().
+					WithClassName(collectionName).
+					WithID(movies[i].id).
+					WithProperties(map[string]interface{}{
+						"title":     movies[i].title,
+						"director":  movies[i].director,
+						"languages": movies[i].languages,
+					}).
+					Do(context.Background())
+				require.NoError(t, err)
+			}
+		})
+
+		t.Run("contains", func(t *testing.T) {
+			tests := []struct {
+				name        string
+				where       *filters.WhereBuilder
+				property    string
+				expectedIds []string
+			}{
+				{
+					name: "contains any languages (1)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsAny).
+						WithValueString("English", "German"),
+					property:    "languages",
+					expectedIds: []string{movies[0].id, movies[2].id, movies[4].id, movies[5].id},
+				},
+				{
+					name: "contains all languages (1)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsAll).
+						WithValueString("English", "German"),
+					property:    "languages",
+					expectedIds: []string{movies[4].id},
+				},
+				{
+					name: "contains none languages (1)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsNone).
+						WithValueString("English", "German"),
+					property:    "languages",
+					expectedIds: []string{movies[1].id, movies[3].id},
+				},
+
+				{
+					name: "contains any languages (2)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsAny).
+						WithValueString("French", "Polish"),
+					property:    "languages",
+					expectedIds: []string{movies[0].id, movies[1].id, movies[3].id, movies[5].id},
+				},
+				{
+					name: "contains all languages (2)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsAll).
+						WithValueString("French", "Polish"),
+					property:    "languages",
+					expectedIds: []string{movies[5].id},
+				},
+				{
+					name: "contains none languages (2)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsNone).
+						WithValueString("French", "Polish"),
+					property:    "languages",
+					expectedIds: []string{movies[2].id, movies[4].id},
+				},
+
+				{
+					name: "contains any languages (3)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsAny).
+						WithValueString("Portugese", "Czech", "Romanian", "German"),
+					property:    "languages",
+					expectedIds: []string{movies[2].id, movies[4].id},
+				},
+				{
+					name: "contains all languages (3)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsAll).
+						WithValueString("Portugese", "Czech", "Romanian", "German"),
+					property:    "languages",
+					expectedIds: []string{movies[2].id},
+				},
+				{
+					name: "contains none languages (3)",
+					where: filters.Where().
+						WithPath([]string{"languages"}).
+						WithOperator(filters.ContainsNone).
+						WithValueString("Portugese", "Czech", "Romanian", "German"),
+					property:    "languages",
+					expectedIds: []string{movies[0].id, movies[1].id, movies[3].id, movies[5].id},
+				},
+			}
+			for _, tt := range tests {
+				t.Run(tt.name, func(t *testing.T) {
+					fields := []graphql.Field{
+						{Name: tt.property},
+						{Name: "_additional", Fields: []graphql.Field{{Name: "id"}}},
+					}
+					resp, err := client.GraphQL().Get().
+						WithClassName(collectionName).
+						WithWhere(tt.where).
+						WithFields(fields...).
+						Do(context.Background())
+					require.NoError(t, err)
+					resultIds := acceptance_with_go_client.GetIds(t, resp, collectionName)
+					assert.ElementsMatch(t, resultIds, tt.expectedIds)
+				})
+			}
+		})
+
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/filters_tests/contains_text_test.go

@@ -0,0 +1,472 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package filters_tests
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	acceptance_with_go_client "acceptance_tests_with_client"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/require"
+	wvt "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/entities/schema"
+)
+
+func testContainsText(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.NoError(t, err)
+
+		defer func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.NoError(t, err)
+		}()
+
+		ctx := context.Background()
+		className := "ContainsText"
+		id := "be6452f4-5db6-4a41-bfef-ff5dffd4ab16"
+		texts := []string{
+			" Hello You*-beautiful_world?!",
+			"HoW yOU_DOin? ",
+		}
+
+		t.Run("init data", func(t *testing.T) {
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name:         "textField",
+						DataType:     schema.DataTypeText.PropString(),
+						Tokenization: models.PropertyTokenizationField,
+					},
+					{
+						Name:         "textWhitespace",
+						DataType:     schema.DataTypeText.PropString(),
+						Tokenization: models.PropertyTokenizationWhitespace,
+					},
+					{
+						Name:         "textLowercase",
+						DataType:     schema.DataTypeText.PropString(),
+						Tokenization: models.PropertyTokenizationLowercase,
+					},
+					{
+						Name:         "textWord",
+						DataType:     schema.DataTypeText.PropString(),
+						Tokenization: models.PropertyTokenizationWord,
+					},
+
+					{
+						Name:         "textsField",
+						DataType:     schema.DataTypeTextArray.PropString(),
+						Tokenization: models.PropertyTokenizationField,
+					},
+					{
+						Name:         "textsWhitespace",
+						DataType:     schema.DataTypeTextArray.PropString(),
+						Tokenization: models.PropertyTokenizationWhitespace,
+					},
+					{
+						Name:         "textsLowercase",
+						DataType:     schema.DataTypeTextArray.PropString(),
+						Tokenization: models.PropertyTokenizationLowercase,
+					},
+					{
+						Name:         "textsWord",
+						DataType:     schema.DataTypeTextArray.PropString(),
+						Tokenization: models.PropertyTokenizationWord,
+					},
+				},
+			}
+
+			err := client.Schema().ClassCreator().
+				WithClass(class).
+				Do(ctx)
+			require.NoError(t, err)
+
+			wrap, err := client.Data().Creator().
+				WithClassName(className).
+				WithID(id).
+				WithProperties(map[string]interface{}{
+					"textField":       texts[0],
+					"textWhitespace":  texts[0],
+					"textLowercase":   texts[0],
+					"textWord":        texts[0],
+					"textsField":      texts,
+					"textsWhitespace": texts,
+					"textsLowercase":  texts,
+					"textsWord":       texts,
+				}).
+				Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, wrap)
+			require.NotNil(t, wrap.Object)
+			require.Equal(t, strfmt.UUID(id), wrap.Object.ID)
+
+			// Give time for graphql to receive and rebuild the schema internally
+			time.Sleep(3 * time.Second)
+		})
+
+		t.Run("search using contains", func(t *testing.T) {
+			type testCase struct {
+				propName      string
+				operator      filters.WhereOperator
+				values        []string
+				expectedFound bool
+			}
+
+			testCases := []testCase{}
+			testCases = append(testCases,
+				testCase{
+					propName:      "textField",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello You*-beautiful_world?!", "HoW yOU_DOin?"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textField",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello You*-beautiful_world?!", "HoW yOU_DOin?"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textField",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello You*-beautiful_world?!", "HoW yOU_DOin?"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textsField",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello You*-beautiful_world?!", "HoW yOU_DOin?"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsField",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello You*-beautiful_world?!", "HoW yOU_DOin?"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsField",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello You*-beautiful_world?!", "HoW yOU_DOin?"},
+					expectedFound: false,
+				},
+
+				testCase{
+					propName:      "textWord",
+					operator:      filters.ContainsAny,
+					values:        []string{"HELLO", "doin"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textWord",
+					operator:      filters.ContainsAll,
+					values:        []string{"HELLO", "doin"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textWord",
+					operator:      filters.ContainsNone,
+					values:        []string{"HELLO", "doin"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textsWord",
+					operator:      filters.ContainsAny,
+					values:        []string{"HELLO", "doin"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsWord",
+					operator:      filters.ContainsAll,
+					values:        []string{"HELLO", "doin"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsWord",
+					operator:      filters.ContainsNone,
+					values:        []string{"HELLO", "doin"},
+					expectedFound: false,
+				},
+
+				testCase{
+					propName:      "textField",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textField",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textField",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsField",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textsField",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textsField",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textWhitespace",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textWhitespace",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textWhitespace",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textsWhitespace",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsWhitespace",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsWhitespace",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textLowercase",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textLowercase",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textLowercase",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textsLowercase",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsLowercase",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsLowercase",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textWord",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textWord",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textWord",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+				testCase{
+					propName:      "textsWord",
+					operator:      filters.ContainsAny,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsWord",
+					operator:      filters.ContainsAll,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: true,
+				},
+				testCase{
+					propName:      "textsWord",
+					operator:      filters.ContainsNone,
+					values:        []string{"Hello", "HoW"},
+					expectedFound: false,
+				},
+			)
+
+			for _, propName := range []string{"textField", "textsField"} {
+				testCases = append(testCases,
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAny,
+						values:        []string{"hello", "world"},
+						expectedFound: false,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAll,
+						values:        []string{"hello", "world"},
+						expectedFound: false,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsNone,
+						values:        []string{"hello", "world"},
+						expectedFound: true,
+					},
+				)
+			}
+			for _, propName := range []string{"textWhitespace", "textsWhitespace"} {
+				testCases = append(testCases,
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAny,
+						values:        []string{"hello", "world"},
+						expectedFound: false,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAll,
+						values:        []string{"hello", "world"},
+						expectedFound: false,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsNone,
+						values:        []string{"hello", "world"},
+						expectedFound: true,
+					},
+				)
+			}
+			for _, propName := range []string{"textLowercase", "textsLowercase"} {
+				testCases = append(testCases,
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAny,
+						values:        []string{"hello", "world"},
+						expectedFound: true,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAll,
+						values:        []string{"hello", "world"},
+						expectedFound: false,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsNone,
+						values:        []string{"hello", "world"},
+						expectedFound: false,
+					},
+				)
+			}
+			for _, propName := range []string{"textWord", "textsWord"} {
+				testCases = append(testCases,
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAny,
+						values:        []string{"hello", "world"},
+						expectedFound: true,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsAll,
+						values:        []string{"hello", "world"},
+						expectedFound: true,
+					},
+					testCase{
+						propName:      propName,
+						operator:      filters.ContainsNone,
+						values:        []string{"hello", "world"},
+						expectedFound: false,
+					},
+				)
+			}
+
+			for _, tc := range testCases {
+				t.Run(fmt.Sprintf("%+v", tc), func(t *testing.T) {
+					where := filters.Where().
+						WithPath([]string{tc.propName}).
+						WithOperator(tc.operator).
+						WithValueText(tc.values...)
+					field := graphql.Field{
+						Name:   "_additional",
+						Fields: []graphql.Field{{Name: "id"}},
+					}
+
+					resp, err := client.GraphQL().Get().
+						WithClassName(className).
+						WithWhere(where).
+						WithFields(field).
+						Do(ctx)
+					require.NoError(t, err)
+
+					ids := acceptance_with_go_client.GetIds(t, resp, className)
+					if tc.expectedFound {
+						require.ElementsMatch(t, ids, []string{id})
+					} else {
+						require.Empty(t, ids)
+					}
+				})
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/filters_tests/numerical_filters_test.go

@@ -0,0 +1,442 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package filters_tests
+
+import (
+	"context"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "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/entities/schema"
+)
+
+func testNumericalFilters(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		className := "NumericalClass"
+
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.NoError(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+		cleanup()
+		defer cleanup()
+
+		randPool := 100
+		randInts := make([]int64, randPool)
+		randNumbers := make([]float64, randPool)
+		randDates := make([]time.Time, randPool)
+		selectedRandIds := make([]int, 0, 6)
+		r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+		batches := 50
+		perBatch := 200
+
+		t.Run("create schema", func(t *testing.T) {
+			vTrue := true
+			vFalse := false
+
+			class := &models.Class{
+				Class:      className,
+				Vectorizer: "none",
+				Properties: []*models.Property{
+					{
+						Name:              "int_filterable",
+						DataType:          schema.DataTypeInt.PropString(),
+						IndexFilterable:   &vTrue,
+						IndexRangeFilters: &vFalse,
+					},
+					{
+						Name:              "int_rangeable",
+						DataType:          schema.DataTypeInt.PropString(),
+						IndexFilterable:   &vFalse,
+						IndexRangeFilters: &vTrue,
+					},
+					{
+						Name:              "number_filterable",
+						DataType:          schema.DataTypeNumber.PropString(),
+						IndexFilterable:   &vTrue,
+						IndexRangeFilters: &vFalse,
+					},
+					{
+						Name:              "number_rangeable",
+						DataType:          schema.DataTypeNumber.PropString(),
+						IndexFilterable:   &vFalse,
+						IndexRangeFilters: &vTrue,
+					},
+					{
+						Name:              "date_filterable",
+						DataType:          schema.DataTypeDate.PropString(),
+						IndexFilterable:   &vTrue,
+						IndexRangeFilters: &vFalse,
+					},
+					{
+						Name:              "date_rangeable",
+						DataType:          schema.DataTypeDate.PropString(),
+						IndexFilterable:   &vFalse,
+						IndexRangeFilters: &vTrue,
+					},
+					{
+						Name:     "delete",
+						DataType: schema.DataTypeBoolean.PropString(),
+					},
+				},
+			}
+
+			err = client.Schema().ClassCreator().
+				WithClass(class).
+				Do(context.Background())
+			require.NoError(t, err)
+		})
+
+		t.Run("generate random data", func(t *testing.T) {
+			for i := 0; i < randPool; i++ {
+				randInts[i] = int64(r.Uint32())
+				randNumbers[i] = r.Float64()
+				randDates[i] = time.Unix(0, 0).Add(time.Hour * time.Duration(r.Int63n(1_000_000)))
+			}
+
+			uniqueSelectedRandIds := map[int]struct{}{}
+			objects := make([]*models.Object, 0, perBatch)
+			for batch := 0; batch < batches; batch++ {
+				objects = objects[:0]
+
+				for i := 0; i < perBatch; i++ {
+					randId := r.Intn(randPool)
+					toDelete := i%2 == 0
+					// collect only the ones not to be deleted later on
+					if !toDelete {
+						uniqueSelectedRandIds[randId] = struct{}{}
+					}
+					uuid_, err := uuid.NewRandom()
+					require.NoError(t, err)
+
+					objects = append(objects, &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(uuid_.String()),
+						Properties: map[string]interface{}{
+							"int_filterable":    randInts[randId],
+							"int_rangeable":     randInts[randId],
+							"number_filterable": randNumbers[randId],
+							"number_rangeable":  randNumbers[randId],
+							"date_filterable":   randDates[randId],
+							"date_rangeable":    randDates[randId],
+							"delete":            toDelete,
+						},
+					})
+				}
+
+				responses, err := client.Batch().ObjectsBatcher().
+					WithObjects(objects...).
+					Do(context.Background())
+				require.NoError(t, err)
+				require.Len(t, responses, perBatch)
+
+				for _, response := range responses {
+					s := response.Result.Status
+					require.Equal(t, "SUCCESS", *s)
+				}
+			}
+
+			i, c := 0, cap(selectedRandIds)
+			for id := range uniqueSelectedRandIds {
+				if i == c {
+					break
+				}
+				selectedRandIds = append(selectedRandIds, id)
+				i++
+			}
+			for j := i; j < c; j++ {
+				selectedRandIds = append(selectedRandIds, selectedRandIds[j-i])
+			}
+		})
+
+		gqlGet := func(where *filters.WhereBuilder) []string {
+			resp, err := client.GraphQL().Get().
+				WithClassName(className).
+				WithLimit(batches * perBatch).
+				WithWhere(where).
+				WithFields(graphql.Field{
+					Name: "_additional", Fields: []graphql.Field{{Name: "id"}},
+				}).
+				Do(context.Background())
+			require.NoError(t, err)
+			require.Empty(t, resp.Errors)
+
+			results := resp.Data["Get"].(map[string]interface{})[className].([]interface{})
+			ids := make([]string, len(results))
+			for i := range ids {
+				ids[i] = results[i].(map[string]interface{})["_additional"].(map[string]interface{})["id"].(string)
+			}
+			return ids
+		}
+		equalInt := func(propName string, val int64) []string {
+			return gqlGet(filters.Where().
+				WithPath([]string{propName}).
+				WithOperator(filters.Equal).
+				WithValueInt(val))
+		}
+		equalNumber := func(propName string, val float64) []string {
+			return gqlGet(filters.Where().
+				WithPath([]string{propName}).
+				WithOperator(filters.Equal).
+				WithValueNumber(val))
+		}
+		equalDate := func(propName string, val time.Time) []string {
+			return gqlGet(filters.Where().
+				WithPath([]string{propName}).
+				WithOperator(filters.Equal).
+				WithValueDate(val))
+		}
+		unionInt := func(propName string, val1, val2 int64) []string {
+			return gqlGet(filters.Where().
+				WithOperator(filters.Or).
+				WithOperands(
+					[]*filters.WhereBuilder{
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.LessThan).
+							WithValueInt(val1),
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.GreaterThanEqual).
+							WithValueInt(val2),
+					}))
+		}
+		unionNumber := func(propName string, val1, val2 float64) []string {
+			return gqlGet(filters.Where().
+				WithOperator(filters.Or).
+				WithOperands(
+					[]*filters.WhereBuilder{
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.LessThan).
+							WithValueNumber(val1),
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.GreaterThanEqual).
+							WithValueNumber(val2),
+					}))
+		}
+		unionDate := func(propName string, val1, val2 time.Time) []string {
+			return gqlGet(filters.Where().
+				WithOperator(filters.Or).
+				WithOperands(
+					[]*filters.WhereBuilder{
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.LessThan).
+							WithValueDate(val1),
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.GreaterThanEqual).
+							WithValueDate(val2),
+					}))
+		}
+		intersectionInt := func(propName string, val1, val2 int64) []string {
+			return gqlGet(filters.Where().
+				WithOperator(filters.And).
+				WithOperands(
+					[]*filters.WhereBuilder{
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.GreaterThanEqual).
+							WithValueInt(val1),
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.LessThanEqual).
+							WithValueInt(val2),
+					}))
+		}
+		intersectionNumber := func(propName string, val1, val2 float64) []string {
+			return gqlGet(filters.Where().
+				WithOperator(filters.And).
+				WithOperands(
+					[]*filters.WhereBuilder{
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.GreaterThanEqual).
+							WithValueNumber(val1),
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.LessThanEqual).
+							WithValueNumber(val2),
+					}))
+		}
+		intersectionDate := func(propName string, val1, val2 time.Time) []string {
+			return gqlGet(filters.Where().
+				WithOperator(filters.And).
+				WithOperands(
+					[]*filters.WhereBuilder{
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.GreaterThanEqual).
+							WithValueDate(val1),
+						filters.Where().
+							WithPath([]string{propName}).
+							WithOperator(filters.LessThanEqual).
+							WithValueDate(val2),
+					}))
+		}
+
+		randId1 := selectedRandIds[0]
+		randId2 := selectedRandIds[1]
+		randId3 := selectedRandIds[2]
+		randId4 := selectedRandIds[3]
+		randId5 := selectedRandIds[4]
+		randId6 := selectedRandIds[5]
+
+		runQueries := func(t *testing.T) {
+			t.Run("equal int", func(t *testing.T) {
+				int1, int2 := randInts[randId1], randInts[randId2]
+
+				filterableUuids1 := equalInt("int_filterable", int1)
+				rangeableUuids1 := equalInt("int_rangeable", int1)
+				assert.GreaterOrEqual(t, len(filterableUuids1), 1)
+				assert.ElementsMatch(t, filterableUuids1, rangeableUuids1)
+
+				filterableUuids2 := equalInt("int_filterable", int2)
+				rangeableUuids2 := equalInt("int_rangeable", int2)
+				assert.GreaterOrEqual(t, len(filterableUuids2), 1)
+				assert.ElementsMatch(t, filterableUuids2, rangeableUuids2)
+			})
+
+			t.Run("equal number", func(t *testing.T) {
+				number1, number2 := randNumbers[randId1], randNumbers[randId2]
+
+				filterableUuids1 := equalNumber("number_filterable", number1)
+				rangeableUuids1 := equalNumber("number_rangeable", number1)
+				assert.GreaterOrEqual(t, len(filterableUuids1), 1)
+				assert.ElementsMatch(t, filterableUuids1, rangeableUuids1)
+
+				filterableUuids2 := equalNumber("number_filterable", number2)
+				rangeableUuids2 := equalNumber("number_rangeable", number2)
+				assert.GreaterOrEqual(t, len(filterableUuids2), 1)
+				assert.ElementsMatch(t, filterableUuids2, rangeableUuids2)
+			})
+
+			t.Run("equal date", func(t *testing.T) {
+				date1, date2 := randDates[randId1], randDates[randId2]
+
+				filterableUuids1 := equalDate("date_filterable", date1)
+				rangeableUuids1 := equalDate("date_rangeable", date1)
+				assert.GreaterOrEqual(t, len(filterableUuids1), 1)
+				assert.ElementsMatch(t, filterableUuids1, rangeableUuids1)
+
+				filterableUuids2 := equalDate("date_filterable", date2)
+				rangeableUuids2 := equalDate("date_rangeable", date2)
+				assert.GreaterOrEqual(t, len(filterableUuids2), 1)
+				assert.ElementsMatch(t, filterableUuids2, rangeableUuids2)
+			})
+
+			t.Run("union int", func(t *testing.T) {
+				int1, int2 := randInts[randId3], randInts[randId4]
+				if int1 > int2 {
+					int1, int2 = int2, int1
+				}
+
+				filterableUuids := unionInt("int_filterable", int1, int2)
+				rangeableUuids := unionInt("int_rangeable", int1, int2)
+				assert.GreaterOrEqual(t, len(filterableUuids), 1)
+				assert.ElementsMatch(t, filterableUuids, rangeableUuids)
+			})
+
+			t.Run("union number", func(t *testing.T) {
+				number1, number2 := randNumbers[randId3], randNumbers[randId4]
+				if number1 > number2 {
+					number1, number2 = number2, number1
+				}
+
+				filterableUuids := unionNumber("number_filterable", number1, number2)
+				rangeableUuids := unionNumber("number_rangeable", number1, number2)
+				assert.GreaterOrEqual(t, len(filterableUuids), 1)
+				assert.ElementsMatch(t, filterableUuids, rangeableUuids)
+			})
+
+			t.Run("union date", func(t *testing.T) {
+				date1, date2 := randDates[randId3], randDates[randId4]
+				if date1.After(date2) {
+					date1, date2 = date2, date1
+				}
+
+				filterableUuids := unionDate("date_filterable", date1, date2)
+				rangeableUuids := unionDate("date_rangeable", date1, date2)
+				assert.GreaterOrEqual(t, len(filterableUuids), 1)
+				assert.ElementsMatch(t, filterableUuids, rangeableUuids)
+			})
+
+			t.Run("intersection int", func(t *testing.T) {
+				int1, int2 := randInts[randId5], randInts[randId6]
+				if int1 > int2 {
+					int1, int2 = int2, int1
+				}
+
+				filterableUuids := intersectionInt("int_filterable", int1, int2)
+				rangeableUuids := intersectionInt("int_rangeable", int1, int2)
+				assert.GreaterOrEqual(t, len(filterableUuids), 1)
+				assert.ElementsMatch(t, filterableUuids, rangeableUuids)
+			})
+
+			t.Run("intersection number", func(t *testing.T) {
+				number1, number2 := randNumbers[randId5], randNumbers[randId6]
+				if number1 > number2 {
+					number1, number2 = number2, number1
+				}
+
+				filterableUuids := intersectionNumber("number_filterable", number1, number2)
+				rangeableUuids := intersectionNumber("number_rangeable", number1, number2)
+				assert.GreaterOrEqual(t, len(filterableUuids), 1)
+				assert.ElementsMatch(t, filterableUuids, rangeableUuids)
+			})
+
+			t.Run("intersection date", func(t *testing.T) {
+				date1, date2 := randDates[randId5], randDates[randId6]
+				if date1.After(date2) {
+					date1, date2 = date2, date1
+				}
+
+				filterableUuids := intersectionDate("date_filterable", date1, date2)
+				rangeableUuids := intersectionDate("date_rangeable", date1, date2)
+				assert.GreaterOrEqual(t, len(filterableUuids), 1)
+				assert.ElementsMatch(t, filterableUuids, rangeableUuids)
+			})
+		}
+
+		t.Run("queries before delete", runQueries)
+
+		t.Run("delete some data", func(t *testing.T) {
+			resp, err := client.Batch().ObjectsBatchDeleter().
+				WithClassName(className).
+				WithWhere(filters.Where().
+					WithOperator(filters.Equal).
+					WithPath([]string{"delete"}).
+					WithValueBoolean(true)).
+				Do(context.Background())
+			require.NoError(t, err)
+			require.Equal(t, int64(0), resp.Results.Failed)
+			require.Equal(t, int64(batches*perBatch/2), resp.Results.Successful)
+		})
+
+		t.Run("queries after delete", runQueries)
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/filters_tests/regex_test.go

@@ -0,0 +1,136 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package filters_tests
+
+import (
+	"context"
+	"testing"
+
+	acceptance_with_go_client "acceptance_tests_with_client"
+
+	"github.com/stretchr/testify/require"
+	wvt "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/entities/schema"
+)
+
+func TestWhereFilter_Regex(t *testing.T) {
+	ctx := context.Background()
+	config := wvt.Config{Scheme: "http", Host: "localhost:8080"}
+	client, err := wvt.NewClient(config)
+	require.NoError(t, err)
+	require.NotNil(t, client)
+	// clean DB
+	err = client.Schema().AllDeleter().Do(ctx)
+	require.NoError(t, err)
+
+	t.Run("special characters in where filter value", func(t *testing.T) {
+		vectorizer := "text2vec-contextionary"
+		id1 := "00000000-0000-0000-0000-000000000001"
+		className := "Regex"
+
+		class := &models.Class{
+			Class: className,
+			Properties: []*models.Property{
+				{
+					Name:         "summary",
+					DataType:     []string{schema.DataTypeText.String()},
+					Tokenization: "field",
+					ModuleConfig: map[string]interface{}{
+						vectorizer: map[string]interface{}{
+							"skip":                  true,
+							"vectorizePropertyName": "false",
+						},
+					},
+				},
+				{
+					Name:         "summaries",
+					DataType:     []string{schema.DataTypeTextArray.String()},
+					Tokenization: "field",
+					ModuleConfig: map[string]interface{}{
+						vectorizer: map[string]interface{}{
+							"skip":                  false,
+							"vectorizePropertyName": "false",
+						},
+					},
+				},
+			},
+		}
+		err = client.Schema().ClassCreator().WithClass(class).Do(ctx)
+		require.NoError(t, err)
+		text := `The Hitchhiker's Guide to the Galaxy by Douglas Adams is a comedic science) fiction masterpiece that follows the bewildering adventures of Arthur Dent, an unwitting Earthling, after the destruction of his planet to make way for an interstellar highway. Joined by Ford Prefect, a researcher for the titular guidebook, Zaphod Beeblebrox, a two-headed ex-president, Trillian, the sole human survivor, and Marvin, a depressed robot, Arthur navigates the cosmos while encountering absurdity and philosophical musings. Adams' satirical wit and irreverent humor make this quintessential work a hilarious exploration of the absurdities of life, space, and everything in between.`
+		_, err = client.Data().Creator().
+			WithClassName(className).
+			WithID(id1).
+			WithProperties(map[string]interface{}{
+				"summary":   text,
+				"summaries": []string{text},
+			}).
+			Do(ctx)
+		require.NoError(t, err)
+		exists, err := client.Data().Checker().WithClassName(className).WithID(id1).Do(ctx)
+		require.NoError(t, err)
+		require.True(t, exists)
+		tests := []struct {
+			name  string
+			where *filters.WhereBuilder
+		}{
+			{
+				name: "special character in text array property",
+				where: filters.Where().
+					WithPath([]string{"summaries"}).
+					WithOperator(filters.Like).
+					WithValueString("*science)*"),
+			},
+			{
+				name: "special character in text property",
+				where: filters.Where().
+					WithPath([]string{"summary"}).
+					WithOperator(filters.Like).
+					WithValueString("*science)*"),
+			},
+			{
+				name: "without special character in text array property",
+				where: filters.Where().
+					WithPath([]string{"summaries"}).
+					WithOperator(filters.Like).
+					WithValueString("*science*"),
+			},
+			{
+				name: "without special character in text property",
+				where: filters.Where().
+					WithPath([]string{"summary"}).
+					WithOperator(filters.Like).
+					WithValueString("*science*"),
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				fields := []graphql.Field{
+					{Name: "_additional", Fields: []graphql.Field{{Name: "id"}}},
+				}
+				resp, err := client.GraphQL().Get().
+					WithClassName(className).
+					WithWhere(tt.where).
+					WithFields(fields...).
+					Do(ctx)
+				require.Nil(t, err)
+				require.Empty(t, resp.Errors)
+				ids := acceptance_with_go_client.GetIds(t, resp, className)
+				require.NotEmpty(t, ids)
+				require.ElementsMatch(t, ids, []string{id1})
+			})
+		}
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/filters_tests/where_test.go

@@ -0,0 +1,78 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package filters_tests
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestWhereFilter_SingleNode_Contains(t *testing.T) {
+	t.Run("Contains", testContains("localhost:8080"))
+	t.Run("Contains text", testContainsText("localhost:8080"))
+	t.Run("Contains movies", testContainsMovies("localhost:8080"))
+}
+
+func TestWhereFilter_SingleNode_Numerical(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("with rangeable on disk", func(t *testing.T) {
+		compose, err := docker.New().
+			WithWeaviate().
+			Start(ctx)
+		require.NoError(t, err)
+		defer func() {
+			require.NoError(t, compose.Terminate(ctx))
+		}()
+
+		endpoint := compose.GetWeaviate().URI()
+
+		t.Run("numerical filters", testNumericalFilters(endpoint))
+	})
+
+	t.Run("with rangeable in memory", func(t *testing.T) {
+		compose, err := docker.New().
+			WithWeaviate().
+			WithWeaviateEnv("INDEX_RANGEABLE_IN_MEMORY", "true").
+			Start(ctx)
+		require.NoError(t, err)
+		defer func() {
+			require.NoError(t, compose.Terminate(ctx))
+		}()
+
+		endpoint := compose.GetWeaviate().URI()
+
+		t.Run("numerical filters", testNumericalFilters(endpoint))
+	})
+}
+
+func TestWhereFilter_Cluster(t *testing.T) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithText2VecContextionary().
+		Start(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("Contains", testContains(endpoint))
+	t.Run("Contains text", testContainsText(endpoint))
+	t.Run("Contains movies", testContainsMovies(endpoint))
+	t.Run("Numerical filters", testNumericalFilters(endpoint))
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/fixtures/allproperties.go

@@ -0,0 +1,186 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package fixtures
+
+import (
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+var (
+	AllPropertiesClassName = "AllProperties"
+	AllPropertiesID1       = "00000000-0000-0000-0000-000000000001"
+	vTrue                  = true
+	vFalse                 = false
+)
+
+var AllPropertiesClass = &models.Class{
+	Class: AllPropertiesClassName,
+	Properties: []*models.Property{
+		{
+			Name:            "objectProperty",
+			DataType:        schema.DataTypeObject.PropString(),
+			IndexFilterable: &vTrue,
+			IndexSearchable: &vFalse,
+			Tokenization:    "",
+			NestedProperties: []*models.NestedProperty{
+				{
+					Name:     "text",
+					DataType: schema.DataTypeText.PropString(),
+				},
+				{
+					Name:     "texts",
+					DataType: schema.DataTypeTextArray.PropString(),
+				},
+				{
+					Name:     "number",
+					DataType: schema.DataTypeNumber.PropString(),
+				},
+				{
+					Name:     "numbers",
+					DataType: schema.DataTypeNumberArray.PropString(),
+				},
+				{
+					Name:     "int",
+					DataType: schema.DataTypeInt.PropString(),
+				},
+				{
+					Name:     "ints",
+					DataType: schema.DataTypeIntArray.PropString(),
+				},
+				{
+					Name:     "date",
+					DataType: schema.DataTypeDate.PropString(),
+				},
+				{
+					Name:     "dates",
+					DataType: schema.DataTypeDateArray.PropString(),
+				},
+				{
+					Name:     "bool",
+					DataType: schema.DataTypeBoolean.PropString(),
+				},
+				{
+					Name:     "bools",
+					DataType: schema.DataTypeBooleanArray.PropString(),
+				},
+				{
+					Name:     "uuid",
+					DataType: schema.DataTypeUUID.PropString(),
+				},
+				{
+					Name:     "uuids",
+					DataType: schema.DataTypeUUIDArray.PropString(),
+				},
+				{
+					Name:            "nested_int",
+					DataType:        schema.DataTypeInt.PropString(),
+					IndexFilterable: &vTrue,
+					IndexSearchable: &vFalse,
+					Tokenization:    "",
+				},
+				{
+					Name:            "nested_number",
+					DataType:        schema.DataTypeNumber.PropString(),
+					IndexFilterable: &vTrue,
+					IndexSearchable: &vFalse,
+					Tokenization:    "",
+				},
+				{
+					Name:            "nested_text",
+					DataType:        schema.DataTypeText.PropString(),
+					IndexFilterable: &vTrue,
+					IndexSearchable: &vTrue,
+					Tokenization:    models.PropertyTokenizationWord,
+				},
+				{
+					Name:            "nested_objects",
+					DataType:        schema.DataTypeObject.PropString(),
+					IndexFilterable: &vTrue,
+					IndexSearchable: &vFalse,
+					Tokenization:    "",
+					NestedProperties: []*models.NestedProperty{
+						{
+							Name:            "nested_bool_lvl2",
+							DataType:        schema.DataTypeBoolean.PropString(),
+							IndexFilterable: &vTrue,
+							IndexSearchable: &vFalse,
+							Tokenization:    "",
+						},
+						{
+							Name:            "nested_numbers_lvl2",
+							DataType:        schema.DataTypeNumberArray.PropString(),
+							IndexFilterable: &vTrue,
+							IndexSearchable: &vFalse,
+							Tokenization:    "",
+						},
+					},
+				},
+				{
+					Name:            "nested_array_objects",
+					DataType:        schema.DataTypeObjectArray.PropString(),
+					IndexFilterable: &vTrue,
+					IndexSearchable: &vFalse,
+					Tokenization:    "",
+					NestedProperties: []*models.NestedProperty{
+						{
+							Name:            "nested_bool_lvl2",
+							DataType:        schema.DataTypeBoolean.PropString(),
+							IndexFilterable: &vTrue,
+							IndexSearchable: &vFalse,
+							Tokenization:    "",
+						},
+						{
+							Name:            "nested_numbers_lvl2",
+							DataType:        schema.DataTypeNumberArray.PropString(),
+							IndexFilterable: &vTrue,
+							IndexSearchable: &vFalse,
+							Tokenization:    "",
+						},
+					},
+				},
+			},
+		},
+	},
+}
+
+var AllPropertiesProperties = map[string]interface{}{
+	"text":          "red",
+	"texts":         []string{"red", "blue"},
+	"number":        float64(1.1),
+	"numbers":       []float64{1.1, 2.2},
+	"int":           int64(1),
+	"ints":          []int64{1, 2},
+	"uuid":          AllPropertiesID1,
+	"uuids":         []string{AllPropertiesID1},
+	"date":          "2009-11-01T23:00:00Z",
+	"dates":         []string{"2009-11-01T23:00:00Z"},
+	"bool":          true,
+	"bools":         []bool{true, false},
+	"nested_int":    int64(11),
+	"nested_number": float64(11.11),
+	"nested_text":   "nested text",
+	"nested_objects": map[string]interface{}{
+		"nested_bool_lvl2":    true,
+		"nested_numbers_lvl2": []float64{11.1, 22.1},
+	},
+	"nested_array_objects": []interface{}{
+		map[string]interface{}{
+			"nested_bool_lvl2":    true,
+			"nested_numbers_lvl2": []float64{111.1, 222.1},
+		},
+		map[string]interface{}{
+			"nested_bool_lvl2":    false,
+			"nested_numbers_lvl2": []float64{112.1, 222.1},
+		},
+	},
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/fixtures/books.go

@@ -0,0 +1,106 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package fixtures
+
+type Book struct {
+	Author, Title, Description, Genre string
+}
+
+func Books() map[string]Book {
+	books := map[string]Book{
+		"00000000-0000-0000-0000-000000000001": {
+			Author:      "J.R.R. Tolkien",
+			Title:       "The Lord of the rings",
+			Description: `"The Lord of the Rings" is a timeless epic fantasy tale penned by J.R.R. Tolkien. Set in the fictional world of Middle-earth, the story follows the quest of Frodo Baggins, a humble hobbit, who is tasked with destroying a powerful and corrupting artifact, the One Ring. Accompanied by a diverse fellowship of companions, including humans, elves, dwarves, and other hobbits, Frodo embarks on a perilous journey across Middle-earth to Mount Doom, the only place where the Ring can be unmade. Along the way, they encounter ancient evils, forge unbreakable bonds of friendship, and face monumental challenges that will test their courage and resolve. As the fate of Middle-earth hangs in the balance, Frodo and his companions must confront the forces of darkness in an epic struggle for the survival of their world. Rich with themes of friendship, sacrifice, and the eternal battle between good and evil, "The Lord of the Rings" remains one of the most beloved and influential works of fantasy literature ever written.`,
+			Genre:       "fantasy",
+		},
+		"00000000-0000-0000-0000-000000000002": {
+			Author:      "Douglas Adams",
+			Title:       "The Hitchhiker's Guide to the Galaxy",
+			Description: `"The Hitchhiker's Guide to the Galaxy" is a comedic science fiction novel written by Douglas Adams. It follows the misadventures of Arthur Dent, an ordinary human who is unexpectedly whisked away from Earth just before its demolition to make way for a hyperspace bypass. Arthur's friend, Ford Prefect, turns out to be an alien researcher for the titular guidebook, a humorous compendium of knowledge for intergalactic travelers. Together, they embark on a journey through space, encountering a quirky cast of characters including the two-headed, three-armed ex-President of the Galaxy, Zaphod Beeblebrox, and the depressed robot Marvin. Filled with absurdity, wit, and biting satire, "The Hitchhiker's Guide to the Galaxy" is a delightful romp through the cosmos that pokes fun at the human condition and the universe at large.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000003": {
+			Author:      "Frank Herbert",
+			Title:       "Dune",
+			Description: `"Dune" is a science fiction masterpiece written by Frank Herbert. Set in a distant future where noble houses vie for control of the desert planet Arrakis, known for its valuable spice melange, the story follows young Paul Atreides as his family assumes stewardship of Arrakis. Paul's journey intertwines with political intrigue, betrayal, and a prophesied destiny that could change the fate of the universe. As Paul navigates the harsh desert landscape and confronts the enigmatic Fremen people, he undergoes a transformation that will shape the course of history. "Dune" is a sweeping epic filled with intricate world-building, complex characters, and philosophical themes that have captivated readers for generations.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000004": {
+			Author:      "Isaac Asimov",
+			Title:       "Foundation",
+			Description: `"Foundation" by Isaac Asimov is a groundbreaking science fiction novel that explores the concept of psychohistory—a mathematical science capable of predicting the future of large populations. Set in a distant future where the Galactic Empire is in decline, the story follows mathematician Hari Seldon, who predicts the imminent fall of civilization. To preserve knowledge and shorten the dark ages that will follow, Seldon establishes the Foundation—a secretive organization tasked with guiding humanity's destiny. Spanning centuries, "Foundation" chronicles the Foundation's efforts to navigate political intrigue, technological advancement, and the rise and fall of empires. Asimov's masterful storytelling and thought-provoking exploration of sociopolitical themes make "Foundation" a timeless classic of science fiction literature.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000005": {
+			Author:      "Liu Cixin",
+			Title:       "The Three-Body Problem",
+			Description: `"The Three-Body Problem" by Liu Cixin is a groundbreaking science fiction novel that melds complex scientific concepts with compelling storytelling. Set against the backdrop of China's Cultural Revolution and its aftermath, the story follows physicist Ye Wenjie as she becomes embroiled in a secretive government project to make contact with extraterrestrial life. Meanwhile, present-day scientist Wang Miao finds himself drawn into a mysterious online game that holds the key to understanding an impending alien invasion. As humanity grapples with the implications of contact with an advanced alien civilization and the existential threats it poses, "The Three-Body Problem" explores themes of scientific discovery, cultural revolution, and the nature of humanity itself. Liu Cixin's visionary narrative and intricate exploration of physics and philosophy make "The Three-Body Problem" a thought-provoking and immersive journey into the unknown.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000006": {
+			Author:      "Richard K. Morgan",
+			Title:       "Altered Carbon",
+			Description: `"Altered Carbon" by Richard K. Morgan is a gripping science fiction novel set in a future where consciousness can be transferred between bodies, known as "sleeves," and death has become nearly obsolete for the wealthy. The story follows Takeshi Kovacs, a former soldier turned private investigator, who is hired to solve the murder of a wealthy aristocrat, Laurens Bancroft. As Kovacs delves deeper into the seedy underbelly of a society where the rich live for centuries and the poor struggle to survive, he uncovers a conspiracy that threatens to unravel the fabric of society itself. Blending hard-boiled detective noir with cyberpunk elements and thought-provoking explorations of identity, morality, and the commodification of life, "Altered Carbon" is a thrilling and immersive exploration of a dystopian future where the line between humanity and technology has blurred beyond recognition.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000007": {
+			Author:      "Jeff VanderMeer",
+			Title:       "Borne",
+			Description: `"Borne" by Jeff VanderMeer is a captivating and surreal science fiction novel set in a post-apocalyptic world devastated by biotech experiments gone awry. The story unfolds in a city overrun by strange and dangerous creatures, where scavenger Rachel discovers a mysterious organism she names Borne. As Rachel nurtures Borne, he rapidly grows and evolves, exhibiting intelligence and abilities beyond comprehension. However, their bond is tested when Borne's origins and true nature are revealed, sparking a journey of discovery and survival in a world where nothing is as it seems. VanderMeer's vivid imagination, lyrical prose, and thought-provoking exploration of humanity, nature, and the ethics of scientific experimentation make "Borne" a mesmerizing and unforgettable reading experience.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000008": {
+			Author:      "Greg Egan",
+			Title:       "Diaspora",
+			Description: `"Diaspora" by Greg Egan is a mind-bending science fiction novel that explores themes of identity, consciousness, and the nature of existence in a universe where humanity has transcended physical limitations. Set in the distant future, the story follows a group of post-human beings known as "polises" who exist as digital entities in vast virtual environments. When a catastrophic event threatens their existence, a diverse cast of characters embarks on a journey of exploration and discovery across the cosmos, encountering enigmatic aliens and grappling with existential questions about the nature of reality. Egan's meticulous attention to scientific detail and thought-provoking speculation on the future evolution of humanity make "Diaspora" a challenging yet rewarding exploration of the boundaries of human potential in an infinitely expanding universe.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000009": {
+			Author:      "Janusz A. Zajdel",
+			Title:       "Limes inferior",
+			Description: `"Limes Inferior" is a renowned novel written by Janusz A. Zajdel, a prominent Polish science fiction writer. Set in a dystopian future, the story takes place in a post-apocalyptic world where humanity's survival is threatened by ecological devastation and totalitarian regimes. The narrative follows the protagonist, Peter Cogito, as he navigates the oppressive society ruled by a powerful government and struggles to find his place in a world filled with corruption, surveillance, and social unrest. As Peter delves deeper into the secrets of his society, he uncovers dark truths about the nature of power and the consequences of unchecked authority. "Limes Inferior" is celebrated for its thought-provoking exploration of political themes, moral dilemmas, and the resilience of the human spirit in the face of adversity.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000010": {
+			Author:      "Walter Tevis",
+			Title:       "The Man Who Fell to Earth",
+			Description: `"The Man Who Fell to Earth" is a thought-provoking science fiction novel written by Walter Tevis. The story revolves around Thomas Jerome Newton, an extraterrestrial being from a drought-stricken planet called Anthea. Disguised as a human, Newton arrives on Earth with advanced technology to save his dying world. He becomes a wealthy industrialist, using his knowledge to revolutionize various industries. However, as he becomes increasingly entangled in Earth's society, Newton grapples with the complexities of human emotions, desires, and vices. The novel explores themes of alienation, loneliness, and the struggle to maintain one's identity in a world vastly different from one's own. "The Man Who Fell to Earth" is a poignant and introspective tale that delves into the human condition and the universal quest for connection and belonging.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000011": {
+			Author:      "Neal Stephenson",
+			Title:       "Seveneves",
+			Description: `"Seveneves" by Neal Stephenson is an epic science fiction novel that begins with the sudden destruction of the Moon, setting off a chain reaction of events that threatens all life on Earth. Facing imminent extinction, humanity races against time to ensure its survival by sending a select group of individuals into space to live aboard hastily constructed space habitats known as the "Cloud Ark." As the survivors grapple with the challenges of adaptation and coexistence in their new environment, tensions rise and alliances shift in the struggle to preserve humanity's future. Spanning thousands of years, "Seveneves" explores themes of resilience, ingenuity, and the endurance of the human spirit in the face of catastrophic adversity. With meticulous attention to scientific detail and grand scope, Neal Stephenson delivers a riveting tale of survival and evolution that transcends the bounds of time and space.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000012": {
+			Author:      "Andy Weir",
+			Title:       "Project Hail Mary",
+			Description: `"Project Hail Mary" is a thrilling science fiction novel by Andy Weir, acclaimed author of "The Martian." The story follows Ryland Grace, a brilliant but solitary scientist who wakes up aboard a spacecraft with no memory of who he is or how he got there. As he pieces together his identity and the purpose of his mission, Ryland discovers that he is humanity's last hope to save Earth from an impending catastrophe. With the help of an unlikely ally, an extraterrestrial organism named Rocky, Ryland embarks on a perilous journey across the cosmos to uncover the truth behind the disaster and find a solution to save mankind. Filled with suspense, humor, and ingenious problem-solving, "Project Hail Mary" is a gripping tale of survival, discovery, and the indomitable human spirit in the face of unimaginable challenges.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000013": {
+			Author:      "Dan Simmons",
+			Title:       "Hyperion",
+			Description: `"Hyperion" by Dan Simmons is a gripping science fiction novel that unfolds as a series of interconnected stories, each told by one of seven pilgrims on a journey to the distant world of Hyperion. Set in a future where humanity has spread across the galaxy, the pilgrims share their tales as they seek answers to the enigmatic Shrike, a legendary creature that resides on Hyperion. As each pilgrim reveals their past, fears, and desires, a larger narrative emerges—one of political intrigue, religious conflict, and existential dread. With rich world-building, complex characters, and a narrative structure reminiscent of Chaucer's "The Canterbury Tales," "Hyperion" is a compelling exploration of humanity's place in the universe, the nature of consciousness, and the search for meaning in an ever-expanding cosmos.`,
+			Genre:       "science-fiction",
+		},
+		"00000000-0000-0000-0000-000000000014": {
+			Author:      "Jacek Dukaj",
+			Title:       "Black Oceans",
+			Description: `"Black Oceans" is a science fiction novel by Polish writer Jacek Dukaj, published in Poland by Supernowa in 2001. The novel fits in the hard science fiction genre, describing the late-21st century Earth facing technological singularity. The novel received the prime Polish award for sci-fi literature, Janusz A. Zajdel Award, for 2001.`,
+			Genre:       "science-fiction",
+		},
+	}
+	return books
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/fixtures/colbert.go

@@ -0,0 +1,124 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package fixtures
+
+import (
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+var (
+	BringYourOwnColBERTClassName       = "BringYourOwnColBERT"
+	BringYourOwnColBERTPropertyName    = "name"
+	BringYourOwnColBERTNamedVectorName = "byoc"
+	NormalVector2dName                 = "normal_2d"
+	MultiVector1dName                  = "multi_1d"
+	MultiVector2dName                  = "multi_2d"
+	MultiVector3dName                  = "multi_3d"
+)
+
+var BringYourOwnColBERTClass = func(className string) *models.Class {
+	return &models.Class{
+		Class: BringYourOwnColBERTClassName,
+		Properties: []*models.Property{
+			{
+				Name: BringYourOwnColBERTPropertyName, DataType: []string{schema.DataTypeText.String()},
+			},
+		},
+		VectorConfig: map[string]models.VectorConfig{
+			BringYourOwnColBERTNamedVectorName: {
+				Vectorizer: map[string]interface{}{
+					"none": map[string]interface{}{},
+				},
+				VectorIndexConfig: map[string]interface{}{
+					"multivector": map[string]interface{}{
+						"enabled": true,
+					},
+				},
+				VectorIndexType: "hnsw",
+			},
+			NormalVector2dName: {
+				Vectorizer: map[string]interface{}{
+					"none": map[string]interface{}{},
+				},
+				VectorIndexType: "hnsw",
+			},
+			MultiVector1dName: {
+				Vectorizer: map[string]interface{}{
+					"none": map[string]interface{}{},
+				},
+				VectorIndexConfig: map[string]interface{}{
+					"multivector": map[string]interface{}{
+						"enabled": true,
+					},
+				},
+				VectorIndexType: "hnsw",
+			},
+			MultiVector2dName: {
+				Vectorizer: map[string]interface{}{
+					"none": map[string]interface{}{},
+				},
+				VectorIndexConfig: map[string]interface{}{
+					"multivector": map[string]interface{}{
+						"enabled": true,
+					},
+				},
+				VectorIndexType: "hnsw",
+			},
+			MultiVector3dName: {
+				Vectorizer: map[string]interface{}{
+					"none": map[string]interface{}{},
+				},
+				VectorIndexConfig: map[string]interface{}{
+					"multivector": map[string]interface{}{
+						"enabled": true,
+					},
+				},
+				VectorIndexType: "hnsw",
+			},
+		},
+	}
+}
+
+var BringYourOwnColBERTObjects = []struct {
+	ID     string
+	Name   string
+	Vector [][]float32
+}{
+	{
+		ID: "00000000-0000-0000-0000-000000000001", Name: "a", Vector: [][]float32{{0.11, 0.12}, {0.13, 0.14}, {0.15, 0.16}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000002", Name: "b", Vector: [][]float32{{0.21, 0.22}, {0.23, 0.24}, {0.25, 0.26}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000003", Name: "c", Vector: [][]float32{{0.31, 0.32}, {0.33, 0.34}, {0.35, 0.36}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000004", Name: "d", Vector: [][]float32{{0.41, 0.42}, {0.43, 0.44}, {0.45, 0.46}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000005", Name: "e", Vector: [][]float32{{0.51, 0.52}, {0.53, 0.54}, {0.55, 0.56}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000006", Name: "f", Vector: [][]float32{{0.61, 0.62}, {0.63, 0.64}, {0.65, 0.66}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000007", Name: "g", Vector: [][]float32{{0.71, 0.72}, {0.73, 0.74}, {0.75, 0.76}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000008", Name: "h", Vector: [][]float32{{0.81, 0.82}, {0.83, 0.84}, {0.85, 0.86}},
+	},
+	{
+		ID: "00000000-0000-0000-0000-000000000009", Name: "h", Vector: [][]float32{{0.91, 0.92}, {0.93, 0.94}, {0.95, 0.96}},
+	},
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/fixtures/food.go

@@ -0,0 +1,545 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package fixtures
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+const (
+	PIZZA_QUATTRO_FORMAGGI_ID = "10523cdd-15a2-42f4-81fa-267fe92f7cd6"
+	PIZZA_FRUTTI_DI_MARE_ID   = "927dd3ac-e012-4093-8007-7799cc7e81e4"
+	PIZZA_HAWAII_ID           = "00000000-0000-0000-0000-000000000000"
+	PIZZA_DOENER_ID           = "5b6a08ba-1d46-43aa-89cc-8b070790c6f2"
+	SOUP_CHICKENSOUP_ID       = "8c156d37-81aa-4ce9-a811-621e2702b825"
+	SOUP_BEAUTIFUL_ID         = "27351361-2898-4d1a-aad7-1ca48253eb0b"
+	SOUP_TRIPE_ID             = "a0b0c0d0-2898-4d1a-aad7-1ca48253eb0b"
+	RISOTTO_RISI_E_BISI_ID    = "da751a25-f573-4715-a893-e607b2de0ba4"
+	RISOTTO_ALLA_PILOTA_ID    = "10c2ee44-7d58-42be-9d64-5766883ca8cb"
+	RISOTTO_AL_NERO_DI_SEPPIA = "696bf381-7f98-40a4-bcad-841780e00e0e"
+)
+
+var IdsByClass = map[string][]string{
+	"Pizza": {
+		PIZZA_QUATTRO_FORMAGGI_ID,
+		PIZZA_FRUTTI_DI_MARE_ID,
+		PIZZA_HAWAII_ID,
+		PIZZA_DOENER_ID,
+	},
+	"Soup": {
+		SOUP_CHICKENSOUP_ID,
+		SOUP_BEAUTIFUL_ID,
+	},
+	"Risotto": {
+		RISOTTO_RISI_E_BISI_ID,
+		RISOTTO_ALLA_PILOTA_ID,
+		RISOTTO_AL_NERO_DI_SEPPIA,
+	},
+}
+
+var BeaconsByClass = map[string][]map[string]string{
+	"Pizza": {
+		{"beacon": makeBeacon("Pizza", PIZZA_QUATTRO_FORMAGGI_ID)},
+		{"beacon": makeBeacon("Pizza", PIZZA_FRUTTI_DI_MARE_ID)},
+		{"beacon": makeBeacon("Pizza", PIZZA_HAWAII_ID)},
+		{"beacon": makeBeacon("Pizza", PIZZA_DOENER_ID)},
+	},
+	"Soup": {
+		{"beacon": makeBeacon("Soup", SOUP_CHICKENSOUP_ID)},
+		{"beacon": makeBeacon("Soup", SOUP_BEAUTIFUL_ID)},
+	},
+	"Risotto": {
+		{"beacon": makeBeacon("Risotto", RISOTTO_RISI_E_BISI_ID)},
+		{"beacon": makeBeacon("Risotto", RISOTTO_ALLA_PILOTA_ID)},
+		{"beacon": makeBeacon("Risotto", RISOTTO_AL_NERO_DI_SEPPIA)},
+	},
+}
+
+var AllIds = []string{
+	PIZZA_QUATTRO_FORMAGGI_ID,
+	PIZZA_FRUTTI_DI_MARE_ID,
+	PIZZA_HAWAII_ID,
+	PIZZA_DOENER_ID,
+
+	SOUP_CHICKENSOUP_ID,
+	SOUP_BEAUTIFUL_ID,
+
+	RISOTTO_RISI_E_BISI_ID,
+	RISOTTO_ALLA_PILOTA_ID,
+	RISOTTO_AL_NERO_DI_SEPPIA,
+}
+
+func makeBeacon(class, id string) string {
+	return fmt.Sprintf("weaviate://localhost/%s/%s", class, id)
+}
+
+// ##### SCHEMA #####
+
+func CreateSchemaPizza(t *testing.T, client *weaviate.Client) {
+	createSchema(t, client, classPizza())
+}
+
+func CreateSchemaSoup(t *testing.T, client *weaviate.Client) {
+	createSchema(t, client, classSoup())
+}
+
+func CreateSchemaRisotto(t *testing.T, client *weaviate.Client) {
+	createSchema(t, client, classRisotto())
+}
+
+func CreateSchemaFood(t *testing.T, client *weaviate.Client) {
+	CreateSchemaPizza(t, client)
+	CreateSchemaSoup(t, client)
+	CreateSchemaRisotto(t, client)
+}
+
+func CreateSchemaPizzaForTenants(t *testing.T, client *weaviate.Client) {
+	createSchema(t, client, classForTenants(classPizza()))
+}
+
+func CreateSchemaPizzaForTenantsWithReplication(t *testing.T, client *weaviate.Client, replicationFactor int64) {
+	createSchema(t, client, classWithReplication(classForTenants(classPizza()), replicationFactor))
+}
+
+func CreateSchemaSoupForTenants(t *testing.T, client *weaviate.Client) {
+	createSchema(t, client, classForTenants(classSoup()))
+}
+
+func CreateSchemaRisottoForTenants(t *testing.T, client *weaviate.Client) {
+	createSchema(t, client, classForTenants(classRisotto()))
+}
+
+func CreateSchemaFoodForTenants(t *testing.T, client *weaviate.Client) {
+	CreateSchemaPizzaForTenants(t, client)
+	CreateSchemaSoupForTenants(t, client)
+	CreateSchemaRisottoForTenants(t, client)
+}
+
+func createSchema(t *testing.T, client *weaviate.Client, class *models.Class) {
+	err := client.Schema().ClassCreator().
+		WithClass(class).
+		Do(context.Background())
+	if err != nil {
+		return
+	}
+
+	require.Nil(t, err)
+}
+
+// ##### CLASSES #####
+
+func classPizza() *models.Class {
+	return &models.Class{
+		Class:               "Pizza",
+		Description:         "A delicious religion like food and arguably the best export of Italy.",
+		InvertedIndexConfig: &models.InvertedIndexConfig{IndexTimestamps: true, UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND},
+		Properties:          classPropertiesFood(),
+	}
+}
+
+func classSoup() *models.Class {
+	return &models.Class{
+		Class:       "Soup",
+		Description: "Mostly water based brew of sustenance for humans.",
+		Properties:  classPropertiesFood(),
+	}
+}
+
+func classRisotto() *models.Class {
+	return &models.Class{
+		Class:               "Risotto",
+		Description:         "Risotto is a northern Italian rice dish cooked with broth.",
+		InvertedIndexConfig: &models.InvertedIndexConfig{IndexTimestamps: true, UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND},
+		Properties:          classPropertiesFood(),
+	}
+}
+
+func classForTenants(class *models.Class) *models.Class {
+	class.MultiTenancyConfig = &models.MultiTenancyConfig{
+		Enabled: true,
+	}
+	return class
+}
+
+func classWithReplication(class *models.Class, replicationFactor int64) *models.Class {
+	class.ReplicationConfig = &models.ReplicationConfig{
+		Factor: replicationFactor,
+	}
+	return class
+}
+
+func classPropertiesFood() []*models.Property {
+	nameProperty := &models.Property{
+		Name:         "name",
+		Description:  "name",
+		DataType:     schema.DataTypeText.PropString(),
+		Tokenization: models.PropertyTokenizationField,
+	}
+	descriptionProperty := &models.Property{
+		Name:        "description",
+		Description: "description",
+		DataType:    schema.DataTypeText.PropString(),
+	}
+	bestBeforeProperty := &models.Property{
+		Name:        "best_before",
+		Description: "You better eat this food before it expires",
+		DataType:    schema.DataTypeDate.PropString(),
+	}
+	priceProperty := &models.Property{
+		Name:        "price",
+		Description: "price",
+		DataType:    schema.DataTypeNumber.PropString(),
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"skip": true,
+			},
+		},
+	}
+
+	return []*models.Property{
+		nameProperty, descriptionProperty, bestBeforeProperty, priceProperty,
+	}
+}
+
+// ##### DATA #####
+
+func CreateDataPizza(t *testing.T, client *weaviate.Client) {
+	createData(t, client, []*models.Object{
+		objectPizzaQuattroFormaggi(),
+		objectPizzaFruttiDiMare(),
+		objectPizzaHawaii(),
+		objectPizzaDoener(),
+	})
+}
+
+func CreateDataSoup(t *testing.T, client *weaviate.Client) {
+	createData(t, client, []*models.Object{
+		objectSoupChicken(),
+		objectSoupBeautiful(),
+	})
+}
+
+func CreateDataRisotto(t *testing.T, client *weaviate.Client) {
+	createData(t, client, []*models.Object{
+		objectRisottoRisiEBisi(),
+		objectRisottoAllaPilota(),
+		objectRisottoAlNeroDiSeppia(),
+	})
+}
+
+func CreateDataFood(t *testing.T, client *weaviate.Client) {
+	createData(t, client, []*models.Object{
+		objectPizzaQuattroFormaggi(),
+		objectPizzaFruttiDiMare(),
+		objectPizzaHawaii(),
+		objectPizzaDoener(),
+
+		objectSoupChicken(),
+		objectSoupBeautiful(),
+
+		objectRisottoRisiEBisi(),
+		objectRisottoAllaPilota(),
+		objectRisottoAlNeroDiSeppia(),
+	})
+}
+
+func createData(t *testing.T, client *weaviate.Client, objects []*models.Object) {
+	resp, err := client.Batch().ObjectsBatcher().
+		WithObjects(objects...).
+		Do(context.Background())
+
+	require.Nil(t, err)
+	require.NotNil(t, resp)
+	require.Len(t, resp, len(objects))
+}
+
+func CreateDataPizzaQuattroFormaggiForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectPizzaQuattroFormaggi(),
+		}
+	})
+}
+
+func CreateDataPizzaFruttiDiMareForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectPizzaFruttiDiMare(),
+		}
+	})
+}
+
+func CreateDataPizzaHawaiiForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectPizzaHawaii(),
+		}
+	})
+}
+
+func CreateDataPizzaDoenerForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectPizzaDoener(),
+		}
+	})
+}
+
+func CreateDataPizzaForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectPizzaQuattroFormaggi(),
+			objectPizzaFruttiDiMare(),
+			objectPizzaHawaii(),
+			objectPizzaDoener(),
+		}
+	})
+}
+
+func CreateDataSoupChickenForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectSoupChicken(),
+		}
+	})
+}
+
+func CreateDataSoupBeautifulForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectSoupBeautiful(),
+		}
+	})
+}
+
+func CreateDataSoupForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectSoupChicken(),
+			objectSoupBeautiful(),
+		}
+	})
+}
+
+func CreateDataRisottoForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectRisottoRisiEBisi(),
+			objectRisottoAllaPilota(),
+			objectRisottoAlNeroDiSeppia(),
+		}
+	})
+}
+
+func CreateDataFoodForTenants(t *testing.T, client *weaviate.Client, tenantNames ...string) {
+	createDataForTenants(t, client, tenantNames, func() []*models.Object {
+		return []*models.Object{
+			objectPizzaQuattroFormaggi(),
+			objectPizzaFruttiDiMare(),
+			objectPizzaHawaii(),
+			objectPizzaDoener(),
+
+			objectSoupChicken(),
+			objectSoupBeautiful(),
+
+			objectRisottoRisiEBisi(),
+			objectRisottoAllaPilota(),
+			objectRisottoAlNeroDiSeppia(),
+		}
+	})
+}
+
+func createDataForTenants(t *testing.T, client *weaviate.Client,
+	tenantNames []string, objectsSupplier func() []*models.Object,
+) {
+	objects := []*models.Object{}
+	for _, name := range tenantNames {
+		for _, object := range objectsSupplier() {
+			object.Tenant = name
+			objects = append(objects, object)
+		}
+	}
+	createData(t, client, objects)
+}
+
+// ##### OBJECTS #####
+
+func objectPizzaQuattroFormaggi() *models.Object {
+	return &models.Object{
+		Class: "Pizza",
+		ID:    PIZZA_QUATTRO_FORMAGGI_ID,
+		Properties: map[string]interface{}{
+			"name":        "Quattro Formaggi",
+			"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+			"price":       float32(1.1),
+			"best_before": "2022-05-03T12:04:40+02:00",
+		},
+	}
+}
+
+func objectPizzaFruttiDiMare() *models.Object {
+	return &models.Object{
+		Class: "Pizza",
+		ID:    PIZZA_FRUTTI_DI_MARE_ID,
+		Properties: map[string]interface{}{
+			"name":        "Frutti di Mare",
+			"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+			"price":       float32(1.2),
+			"best_before": "2022-05-05T07:16:30+02:00",
+		},
+	}
+}
+
+func objectPizzaHawaii() *models.Object {
+	return &models.Object{
+		Class: "Pizza",
+		// this uuid guarantees that it's the first for cursor tests (otherwise
+		// they might be flaky if the randomly generated ids are sometimes higher
+		// and sometimes lower
+		ID: PIZZA_HAWAII_ID,
+		Properties: map[string]interface{}{
+			"name":        "Hawaii",
+			"description": "Universally accepted to be the best pizza ever created.",
+			"price":       float32(1.3),
+		},
+	}
+}
+
+func objectPizzaDoener() *models.Object {
+	return &models.Object{
+		Class: "Pizza",
+		ID:    PIZZA_DOENER_ID,
+		Properties: map[string]interface{}{
+			"name":        "Doener",
+			"description": "A innovation, some say revolution, in the pizza industry.",
+			"price":       float32(1.4),
+		},
+	}
+}
+
+func objectSoupChicken() *models.Object {
+	return &models.Object{
+		Class: "Soup",
+		ID:    SOUP_CHICKENSOUP_ID,
+		Properties: map[string]interface{}{
+			"name":        "ChickenSoup",
+			"description": "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+			"price":       float32(2.1),
+		},
+	}
+}
+
+func objectSoupBeautiful() *models.Object {
+	return &models.Object{
+		Class: "Soup",
+		ID:    SOUP_BEAUTIFUL_ID,
+		Properties: map[string]interface{}{
+			"name":        "Beautiful",
+			"description": "Putting the game of letter soups to a whole new level.",
+			"price":       float32(2.2),
+		},
+	}
+}
+
+func objectRisottoRisiEBisi() *models.Object {
+	return &models.Object{
+		Class: "Risotto",
+		ID:    RISOTTO_RISI_E_BISI_ID,
+		Properties: map[string]interface{}{
+			"name":        "Risi e bisi",
+			"description": "A Veneto spring dish.",
+			"price":       float32(3.1),
+			"best_before": "2022-05-03T12:04:40+02:00",
+		},
+	}
+}
+
+func objectRisottoAllaPilota() *models.Object {
+	return &models.Object{
+		Class: "Risotto",
+		ID:    RISOTTO_ALLA_PILOTA_ID,
+		Properties: map[string]interface{}{
+			"name":        "Risotto alla pilota",
+			"description": "A specialty of Mantua, made with sausage, pork, and Parmesan cheese.",
+			"price":       float32(3.2),
+			"best_before": "2022-05-03T12:04:40+02:00",
+		},
+	}
+}
+
+func objectRisottoAlNeroDiSeppia() *models.Object {
+	return &models.Object{
+		Class: "Risotto",
+		ID:    RISOTTO_AL_NERO_DI_SEPPIA,
+		Properties: map[string]interface{}{
+			"name":        "Risotto al nero di seppia",
+			"description": "A specialty of the Veneto region, made with cuttlefish cooked with their ink-sacs intact, leaving the risotto black .",
+			"price":       float32(3.3),
+		},
+	}
+}
+
+// ##### TENANTS #####
+
+func CreateTenantsPizza(t *testing.T, client *weaviate.Client, tenants ...models.Tenant) {
+	createTenants(t, client, "Pizza", tenants)
+}
+
+func CreateTenantsSoup(t *testing.T, client *weaviate.Client, tenants ...models.Tenant) {
+	createTenants(t, client, "Soup", tenants)
+}
+
+func CreateTenantsRisotto(t *testing.T, client *weaviate.Client, tenants ...models.Tenant) {
+	createTenants(t, client, "Risotto", tenants)
+}
+
+func CreateTenantsFood(t *testing.T, client *weaviate.Client, tenants ...models.Tenant) {
+	CreateTenantsPizza(t, client, tenants...)
+	CreateTenantsSoup(t, client, tenants...)
+	CreateTenantsRisotto(t, client, tenants...)
+}
+
+func createTenants(t *testing.T, client *weaviate.Client, className string, tenants []models.Tenant) {
+	err := client.Schema().TenantsCreator().
+		WithClassName(className).
+		WithTenants(tenants...).
+		Do(context.Background())
+
+	require.Nil(t, err)
+}
+
+type Tenants []models.Tenant
+
+func (t Tenants) Names() []string {
+	names := make([]string, len(t))
+	for i, tenant := range t {
+		names[i] = tenant.Name
+	}
+	return names
+}
+
+func (t Tenants) ByName(name string) *models.Tenant {
+	for _, tenant := range t {
+		if tenant.Name == name {
+			return &tenant
+		}
+	}
+	return nil
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/fixtures/vector_index_configs.go

@@ -0,0 +1,12 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package fixtures

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/grpc_tests/batch_grpc_test.go

@@ -0,0 +1,163 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package grpc_tests
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/grpc"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGRPC_Batch(t *testing.T) {
+	ctx := context.Background()
+	config := wvt.Config{Scheme: "http", Host: "localhost:8080", GrpcConfig: &grpc.Config{Host: "localhost:50051"}}
+	client, err := wvt.NewClient(config)
+	require.NoError(t, err)
+	require.NotNil(t, client)
+	// clean DB
+	err = client.Schema().AllDeleter().Do(ctx)
+	require.NoError(t, err)
+	t.Run("all properties", testGRPCBatchAPI(ctx, client))
+}
+
+func TestGRPC_Batch_Cluster(t *testing.T) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviateClusterWithGRPC().
+		WithText2VecContextionary().
+		Start(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+
+	httpUri := compose.GetWeaviateNode(2).GetEndpoint(docker.HTTP)
+	grpcUri := compose.GetWeaviateNode(2).GetEndpoint(docker.GRPC)
+
+	config := wvt.Config{
+		Scheme: "http", Host: httpUri,
+		GrpcConfig:     &grpc.Config{Host: grpcUri},
+		StartupTimeout: 30 * time.Second,
+	}
+	client, err := wvt.NewClient(config)
+	require.NoError(t, err)
+	require.NotNil(t, client)
+
+	// clean DB
+	err = client.Schema().AllDeleter().Do(ctx)
+	require.NoError(t, err)
+
+	t.Run("all properties", testGRPCBatchAPI(ctx, client))
+	t.Run("multi vectors", testGRPCBatchImportColBERT(ctx, client))
+}
+
+func testGRPCBatchAPI(ctx context.Context, client *wvt.Client) func(t *testing.T) {
+	return func(t *testing.T) {
+		class := fixtures.AllPropertiesClass
+		className := fixtures.AllPropertiesClassName
+		id1 := fixtures.AllPropertiesID1
+		properties := fixtures.AllPropertiesProperties
+		t.Run("create schema", func(t *testing.T) {
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.NoError(t, err)
+		})
+		t.Run("grpc batch import", func(t *testing.T) {
+			objects := []*models.Object{
+				{
+					Class: className,
+					ID:    strfmt.UUID(id1),
+					// These properties slightly differ from the one defined in the class. We are laying them all out as
+					// "base" properties and not as nested properties.
+					// This will cause auto schema to kick in and will make the follower have eventual consistency on the
+					// schema changes. With proper internal retry mechanism this will be transparent to the client.
+					Properties: properties,
+				},
+			}
+			resp, err := client.Batch().ObjectsBatcher().WithObjects(objects...).Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, resp)
+			require.Len(t, resp, 1)
+			require.NotNil(t, resp[0].Result)
+			assert.Nil(t, resp[0].Result.Errors)
+		})
+		t.Run("check", func(t *testing.T) {
+			objs, err := client.Data().ObjectsGetter().WithClassName(className).WithID(id1).Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, objs)
+			require.Len(t, objs, 1)
+			assert.Equal(t, className, objs[0].Class)
+			// We check that the properties are layed out and not nested. This indicates auto schema did it's job.
+			objectProperties, ok := objs[0].Properties.(map[string]interface{})
+			require.True(t, ok)
+			require.Equal(t, len(properties), len(objectProperties))
+		})
+	}
+}
+
+func testGRPCBatchImportColBERT(ctx context.Context, client *wvt.Client) func(t *testing.T) {
+	return func(t *testing.T) {
+		className := fixtures.BringYourOwnColBERTClassName
+		class := fixtures.BringYourOwnColBERTClass(className)
+		objects := fixtures.BringYourOwnColBERTObjects
+		byoc := fixtures.BringYourOwnColBERTNamedVectorName
+		t.Run("create schema", func(t *testing.T) {
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.NoError(t, err)
+		})
+		t.Run("batch import", func(t *testing.T) {
+			objs := []*models.Object{}
+			for _, o := range objects {
+				obj := &models.Object{
+					Class: className,
+					ID:    strfmt.UUID(o.ID),
+					Properties: map[string]interface{}{
+						"name": o.Name,
+					},
+					Vectors: models.Vectors{
+						byoc: o.Vector,
+					},
+				}
+				objs = append(objs, obj)
+			}
+			resp, err := client.Batch().ObjectsBatcher().WithObjects(objs...).Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, resp)
+			require.Len(t, resp, len(objs))
+			for i := range objs {
+				require.NotNil(t, resp[i].Result)
+				assert.Nil(t, resp[i].Result.Errors)
+			}
+		})
+		t.Run("check", func(t *testing.T) {
+			for _, o := range objects {
+				objs, err := client.Data().ObjectsGetter().WithClassName(className).WithID(o.ID).WithVector().Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, objs)
+				require.Len(t, objs, 1)
+				assert.Equal(t, className, objs[0].Class)
+				require.Len(t, objs[0].Vectors, 1)
+				require.IsType(t, [][]float32{}, objs[0].Vectors[byoc])
+				assert.Equal(t, o.Vector, objs[0].Vectors[byoc])
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/multi_tenancy_tests/activation_deactivation_test.go

@@ -0,0 +1,664 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package multi_tenancy_tests
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/fault"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestActivationDeactivation(t *testing.T) {
+	client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+	require.Nil(t, err)
+
+	cleanup := func() {
+		err := client.Schema().AllDeleter().Do(context.Background())
+		require.Nil(t, err)
+	}
+
+	t.Run("deactivate / activate journey", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{
+				Name: "tenantNo1",
+				// default status HOT
+			},
+			{
+				Name:           "tenantNo2",
+				ActivityStatus: models.TenantActivityStatusHOT,
+			},
+			{
+				Name:           "tenantNo3",
+				ActivityStatus: models.TenantActivityStatusCOLD,
+			},
+		}
+		className := "Pizza"
+		ctx := context.Background()
+		pizzaIds := fixtures.IdsByClass[className]
+
+		t.Run("create tenants (1,2,3), populate active tenants (1,2)", func(t *testing.T) {
+			fixtures.CreateSchemaPizzaForTenants(t, client)
+			fixtures.CreateTenantsPizza(t, client, tenants...)
+			fixtures.CreateDataPizzaForTenants(t, client, tenants[:2].Names()...)
+
+			assertTenantActive(t, client, className, tenants[0].Name)
+			assertTenantActive(t, client, className, tenants[1].Name)
+			assertTenantInactive(t, client, className, tenants[2].Name)
+
+			assertActiveTenantObjects(t, client, className, tenants[0].Name, pizzaIds)
+			assertActiveTenantObjects(t, client, className, tenants[1].Name, pizzaIds)
+			assertInactiveTenantObjects(t, client, className, tenants[2].Name)
+		})
+
+		t.Run("deactivate tenant (1)", func(t *testing.T) {
+			err := client.Schema().TenantsUpdater().
+				WithClassName(className).
+				WithTenants(models.Tenant{
+					Name:           tenants[0].Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				}).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertTenantInactive(t, client, className, tenants[0].Name)
+			assertTenantActive(t, client, className, tenants[1].Name)
+			assertTenantInactive(t, client, className, tenants[2].Name)
+
+			assertInactiveTenantObjects(t, client, className, tenants[0].Name)
+			assertActiveTenantObjects(t, client, className, tenants[1].Name, pizzaIds)
+			assertInactiveTenantObjects(t, client, className, tenants[2].Name)
+		})
+
+		t.Run("activate and populate tenant (3)", func(t *testing.T) {
+			err := client.Schema().TenantsUpdater().
+				WithClassName(className).
+				WithTenants(models.Tenant{
+					Name:           tenants[2].Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}).
+				Do(ctx)
+			require.Nil(t, err)
+
+			fixtures.CreateDataPizzaForTenants(t, client, tenants[2].Name)
+
+			assertTenantInactive(t, client, className, tenants[0].Name)
+			assertTenantActive(t, client, className, tenants[1].Name)
+			assertTenantActive(t, client, className, tenants[2].Name)
+
+			assertInactiveTenantObjects(t, client, className, tenants[0].Name)
+			assertActiveTenantObjects(t, client, className, tenants[1].Name, pizzaIds)
+			assertActiveTenantObjects(t, client, className, tenants[2].Name, pizzaIds)
+		})
+
+		t.Run("activate tenant (1)", func(t *testing.T) {
+			err := client.Schema().TenantsUpdater().
+				WithClassName(className).
+				WithTenants(models.Tenant{
+					Name:           tenants[0].Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertTenantActive(t, client, className, tenants[0].Name)
+			assertTenantActive(t, client, className, tenants[1].Name)
+			assertTenantActive(t, client, className, tenants[2].Name)
+
+			assertActiveTenantObjects(t, client, className, tenants[0].Name, pizzaIds)
+			assertActiveTenantObjects(t, client, className, tenants[1].Name, pizzaIds)
+			assertActiveTenantObjects(t, client, className, tenants[2].Name, pizzaIds)
+		})
+
+		t.Run("deactivate tenant (2)", func(t *testing.T) {
+			err := client.Schema().TenantsUpdater().
+				WithClassName(className).
+				WithTenants(models.Tenant{
+					Name:           tenants[1].Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				}).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertTenantActive(t, client, className, tenants[0].Name)
+			assertTenantInactive(t, client, className, tenants[1].Name)
+			assertTenantActive(t, client, className, tenants[2].Name)
+
+			assertActiveTenantObjects(t, client, className, tenants[0].Name, pizzaIds)
+			assertInactiveTenantObjects(t, client, className, tenants[1].Name)
+			assertActiveTenantObjects(t, client, className, tenants[2].Name, pizzaIds)
+		})
+
+		t.Run("delete tenants", func(t *testing.T) {
+			err := client.Schema().TenantsDeleter().
+				WithClassName(className).
+				WithTenants(tenants.Names()...).
+				Do(ctx)
+
+			require.Nil(t, err)
+		})
+	})
+}
+
+type composeFn func(t *testing.T, ctx context.Context) (
+	client *wvt.Client,
+	cleanupFn func(t *testing.T, ctx context.Context),
+	restartFn func(t *testing.T, ctx context.Context) *wvt.Client)
+
+func TestActivationDeactivation_Restarts(t *testing.T) {
+	t.Run("single node", func(t *testing.T) {
+		composeFn := func(t *testing.T, ctx context.Context) (
+			client *wvt.Client,
+			cleanupFn func(t *testing.T, ctx context.Context),
+			restartFn func(t *testing.T, ctx context.Context) *wvt.Client,
+		) {
+			compose, err := docker.New().WithWeaviate().Start(ctx)
+			require.Nil(t, err)
+
+			container := compose.GetWeaviate()
+			client, err = wvt.NewClient(wvt.Config{Scheme: "http", Host: container.URI()})
+			require.Nil(t, err)
+
+			cleanupFn = func(t *testing.T, ctx context.Context) {
+				err := compose.Terminate(ctx)
+				require.Nil(t, err)
+			}
+
+			restartFn = func(t *testing.T, ctx context.Context) *wvt.Client {
+				require.Nil(t, compose.Stop(ctx, container.Name(), nil))
+				require.Nil(t, compose.Start(ctx, container.Name()))
+				client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: container.URI()})
+				require.Nil(t, err)
+
+				return client
+			}
+
+			return
+		}
+
+		testActivationDeactivationWithRestarts(t, composeFn)
+	})
+
+	t.Run("multiple nodes", func(t *testing.T) {
+		t.Skip("flaky test")
+		composeFn := func(t *testing.T, ctx context.Context) (
+			client *wvt.Client,
+			cleanupFn func(t *testing.T, ctx context.Context),
+			restartFn func(t *testing.T, ctx context.Context) *wvt.Client,
+		) {
+			compose, err := docker.New().WithWeaviateCluster(3).Start(ctx)
+			require.Nil(t, err)
+
+			client, err = wvt.NewClient(wvt.Config{Scheme: "http", Host: compose.ContainerURI(0)})
+			require.Nil(t, err)
+
+			cleanupFn = func(t *testing.T, ctx context.Context) {
+				err := compose.Terminate(ctx)
+				require.Nil(t, err)
+			}
+
+			restartFn = func(t *testing.T, ctx context.Context) *wvt.Client {
+				require.Nil(t, compose.StopAt(ctx, 1, nil))
+				require.Nil(t, compose.StartAt(ctx, 1))
+
+				require.Nil(t, compose.StopAt(ctx, 2, nil))
+				require.Nil(t, compose.StartAt(ctx, 2))
+
+				client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: compose.ContainerURI(0)})
+				require.Nil(t, err)
+				return client
+			}
+
+			return
+		}
+
+		testActivationDeactivationWithRestarts(t, composeFn)
+	})
+}
+
+func testActivationDeactivationWithRestarts(t *testing.T, composeFn composeFn) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+
+	client, composeCleanup, restart := composeFn(t, ctx)
+	defer composeCleanup(t, ctx)
+
+	cleanup := func() {
+		err := client.Schema().AllDeleter().Do(context.Background())
+		require.Nil(t, err)
+	}
+
+	classPizza := "Pizza"
+	classSoup := "Soup"
+
+	t.Run("deactivate / activate journey", func(t *testing.T) {
+		defer cleanup()
+
+		createTenants := func(className string, groupId, count int, status string) fixtures.Tenants {
+			tenants := make(fixtures.Tenants, count)
+			for i := 0; i < count; i++ {
+				tenants[i] = models.Tenant{
+					Name:           fmt.Sprintf("tenant_%s_%d_%d", className, groupId, i),
+					ActivityStatus: status,
+				}
+			}
+			return tenants
+		}
+		assertActiveTenants := func(t *testing.T, tenants fixtures.Tenants, className string, expectedIds []string) {
+			for _, tenant := range tenants {
+				assertTenantActive(t, client, className, tenant.Name)
+				assertActiveTenantObjects(t, client, className, tenant.Name, expectedIds)
+			}
+		}
+		assertInactiveTenants := func(t *testing.T, tenants fixtures.Tenants, className string) {
+			for _, tenant := range tenants {
+				assertTenantInactive(t, client, className, tenant.Name)
+				assertInactiveTenantObjects(t, client, className, tenant.Name)
+			}
+		}
+
+		tenants1Pizza := createTenants(classPizza, 1, 5, "") // default status HOT
+		tenants2Pizza := createTenants(classPizza, 2, 4, models.TenantActivityStatusHOT)
+		tenants3Pizza := createTenants(classPizza, 3, 3, models.TenantActivityStatusCOLD)
+		tenants1Soup := createTenants(classSoup, 1, 4, "") // default status HOT
+		tenants2Soup := createTenants(classSoup, 2, 3, models.TenantActivityStatusHOT)
+		tenants3Soup := createTenants(classSoup, 3, 2, models.TenantActivityStatusCOLD)
+		idsPizza := fixtures.IdsByClass[classPizza]
+		idsSoup := fixtures.IdsByClass[classSoup]
+
+		t.Run("create tenants (1,2,3), populate active tenants (1,2)", func(t *testing.T) {
+			fixtures.CreateSchemaPizzaForTenants(t, client)
+			fixtures.CreateTenantsPizza(t, client, tenants1Pizza...)
+			fixtures.CreateTenantsPizza(t, client, tenants2Pizza...)
+			fixtures.CreateTenantsPizza(t, client, tenants3Pizza...)
+			fixtures.CreateDataPizzaForTenants(t, client, tenants1Pizza.Names()...)
+			fixtures.CreateDataPizzaForTenants(t, client, tenants2Pizza.Names()...)
+
+			assertActiveTenants(t, tenants1Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants2Pizza, classPizza, idsPizza)
+			assertInactiveTenants(t, tenants3Pizza, classPizza)
+
+			fixtures.CreateSchemaSoupForTenants(t, client)
+			fixtures.CreateTenantsSoup(t, client, tenants1Soup...)
+			fixtures.CreateTenantsSoup(t, client, tenants2Soup...)
+			fixtures.CreateTenantsSoup(t, client, tenants3Soup...)
+			fixtures.CreateDataSoupForTenants(t, client, tenants1Soup.Names()...)
+			fixtures.CreateDataSoupForTenants(t, client, tenants2Soup.Names()...)
+
+			assertActiveTenants(t, tenants1Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants2Soup, classSoup, idsSoup)
+			assertInactiveTenants(t, tenants3Soup, classSoup)
+		})
+
+		t.Run("deactivate tenants (1)", func(t *testing.T) {
+			tenants := make(fixtures.Tenants, len(tenants1Pizza))
+			for i, tenant := range tenants1Pizza {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				}
+			}
+
+			err := client.Schema().TenantsUpdater().
+				WithClassName(classPizza).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertInactiveTenants(t, tenants1Pizza, classPizza)
+			assertActiveTenants(t, tenants2Pizza, classPizza, idsPizza)
+			assertInactiveTenants(t, tenants3Pizza, classPizza)
+
+			tenants = make(fixtures.Tenants, len(tenants1Soup))
+			for i, tenant := range tenants1Soup {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				}
+			}
+
+			err = client.Schema().TenantsUpdater().
+				WithClassName(classSoup).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertInactiveTenants(t, tenants1Soup, classSoup)
+			assertActiveTenants(t, tenants2Soup, classSoup, idsSoup)
+			assertInactiveTenants(t, tenants3Soup, classSoup)
+		})
+
+		t.Run("restart db, nothing changed", func(t *testing.T) {
+			client = restart(t, ctx)
+
+			assertInactiveTenants(t, tenants1Pizza, classPizza)
+			assertActiveTenants(t, tenants2Pizza, classPizza, idsPizza)
+			assertInactiveTenants(t, tenants3Pizza, classPizza)
+
+			assertInactiveTenants(t, tenants1Soup, classSoup)
+			assertActiveTenants(t, tenants2Soup, classSoup, idsSoup)
+			assertInactiveTenants(t, tenants3Soup, classSoup)
+		})
+
+		t.Run("activate and populate tenants (3)", func(t *testing.T) {
+			tenants := make(fixtures.Tenants, len(tenants3Pizza))
+			for i, tenant := range tenants3Pizza {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}
+			}
+
+			err := client.Schema().TenantsUpdater().
+				WithClassName(classPizza).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			fixtures.CreateDataPizzaForTenants(t, client, tenants3Pizza.Names()...)
+
+			tenants = make(fixtures.Tenants, len(tenants3Soup))
+			for i, tenant := range tenants3Soup {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}
+			}
+
+			err = client.Schema().TenantsUpdater().
+				WithClassName(classSoup).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			fixtures.CreateDataSoupForTenants(t, client, tenants3Soup.Names()...)
+
+			assertInactiveTenants(t, tenants1Pizza, classPizza)
+			assertActiveTenants(t, tenants2Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants3Pizza, classPizza, idsPizza)
+
+			assertInactiveTenants(t, tenants1Soup, classSoup)
+			assertActiveTenants(t, tenants2Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants3Soup, classSoup, idsSoup)
+		})
+
+		t.Run("activate tenants (1)", func(t *testing.T) {
+			tenants := make(fixtures.Tenants, len(tenants1Pizza))
+			for i, tenant := range tenants1Pizza {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}
+			}
+
+			err := client.Schema().TenantsUpdater().
+				WithClassName(classPizza).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			tenants = make(fixtures.Tenants, len(tenants1Soup))
+			for i, tenant := range tenants1Soup {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}
+			}
+
+			err = client.Schema().TenantsUpdater().
+				WithClassName(classSoup).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertActiveTenants(t, tenants1Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants2Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants3Pizza, classPizza, idsPizza)
+
+			assertActiveTenants(t, tenants1Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants2Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants3Soup, classSoup, idsSoup)
+		})
+
+		t.Run("deactivate tenants (2)", func(t *testing.T) {
+			tenants := make(fixtures.Tenants, len(tenants2Pizza))
+			for i, tenant := range tenants2Pizza {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				}
+			}
+
+			err := client.Schema().TenantsUpdater().
+				WithClassName(classPizza).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			tenants = make(fixtures.Tenants, len(tenants2Soup))
+			for i, tenant := range tenants2Soup {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				}
+			}
+
+			err = client.Schema().TenantsUpdater().
+				WithClassName(classSoup).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertActiveTenants(t, tenants1Pizza, classPizza, idsPizza)
+			assertInactiveTenants(t, tenants2Pizza, classPizza)
+			assertActiveTenants(t, tenants3Pizza, classPizza, idsPizza)
+
+			assertActiveTenants(t, tenants1Soup, classSoup, idsSoup)
+			assertInactiveTenants(t, tenants2Soup, classSoup)
+			assertActiveTenants(t, tenants3Soup, classSoup, idsSoup)
+		})
+
+		t.Run("restart db, nothing changed", func(t *testing.T) {
+			client = restart(t, ctx)
+
+			assertActiveTenants(t, tenants1Pizza, classPizza, idsPizza)
+			assertInactiveTenants(t, tenants2Pizza, classPizza)
+			assertActiveTenants(t, tenants3Pizza, classPizza, idsPizza)
+
+			assertActiveTenants(t, tenants1Soup, classSoup, idsSoup)
+			assertInactiveTenants(t, tenants2Soup, classSoup)
+			assertActiveTenants(t, tenants3Soup, classSoup, idsSoup)
+		})
+
+		t.Run("activate already active (1,3), deactivate already inactive (2), nothing changed", func(t *testing.T) {
+			tenants := make(fixtures.Tenants, 0, len(tenants1Pizza)+len(tenants2Pizza)+len(tenants3Pizza))
+			for _, tenant := range tenants1Pizza {
+				tenants = append(tenants, models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				})
+			}
+			for _, tenant := range tenants2Pizza {
+				tenants = append(tenants, models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				})
+			}
+			for _, tenant := range tenants3Pizza {
+				tenants = append(tenants, models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				})
+			}
+
+			err := client.Schema().TenantsUpdater().
+				WithClassName(classPizza).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			tenants = make(fixtures.Tenants, 0, len(tenants1Soup)+len(tenants2Soup)+len(tenants3Soup))
+			for _, tenant := range tenants1Soup {
+				tenants = append(tenants, models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				})
+			}
+			for _, tenant := range tenants2Soup {
+				tenants = append(tenants, models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				})
+			}
+			for _, tenant := range tenants3Soup {
+				tenants = append(tenants, models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				})
+			}
+
+			err = client.Schema().TenantsUpdater().
+				WithClassName(classSoup).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertActiveTenants(t, tenants1Pizza, classPizza, idsPizza)
+			assertInactiveTenants(t, tenants2Pizza, classPizza)
+			assertActiveTenants(t, tenants3Pizza, classPizza, idsPizza)
+
+			assertActiveTenants(t, tenants1Soup, classSoup, idsSoup)
+			assertInactiveTenants(t, tenants2Soup, classSoup)
+			assertActiveTenants(t, tenants3Soup, classSoup, idsSoup)
+		})
+
+		t.Run("activate tenants (2)", func(t *testing.T) {
+			tenants := make(fixtures.Tenants, len(tenants2Pizza))
+			for i, tenant := range tenants2Pizza {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}
+			}
+
+			err := client.Schema().TenantsUpdater().
+				WithClassName(classPizza).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			tenants = make(fixtures.Tenants, len(tenants2Soup))
+			for i, tenant := range tenants2Soup {
+				tenants[i] = models.Tenant{
+					Name:           tenant.Name,
+					ActivityStatus: models.TenantActivityStatusHOT,
+				}
+			}
+
+			err = client.Schema().TenantsUpdater().
+				WithClassName(classSoup).
+				WithTenants(tenants...).
+				Do(ctx)
+			require.Nil(t, err)
+
+			assertActiveTenants(t, tenants1Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants2Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants3Pizza, classPizza, idsPizza)
+
+			assertActiveTenants(t, tenants1Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants2Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants3Soup, classSoup, idsSoup)
+		})
+
+		t.Run("restart db, nothing changed", func(t *testing.T) {
+			client = restart(t, ctx)
+
+			assertActiveTenants(t, tenants1Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants2Pizza, classPizza, idsPizza)
+			assertActiveTenants(t, tenants3Pizza, classPizza, idsPizza)
+
+			assertActiveTenants(t, tenants1Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants2Soup, classSoup, idsSoup)
+			assertActiveTenants(t, tenants3Soup, classSoup, idsSoup)
+		})
+	})
+}
+
+func assertTenantActive(t *testing.T, client *wvt.Client, className, tenantName string) {
+	gotTenants, err := client.Schema().TenantsGetter().
+		WithClassName(className).
+		Do(context.Background())
+	require.Nil(t, err)
+	require.NotEmpty(t, gotTenants)
+
+	byName := fixtures.Tenants(gotTenants).ByName(tenantName)
+	require.NotNil(t, byName)
+	require.Equal(t, models.TenantActivityStatusHOT, byName.ActivityStatus)
+}
+
+func assertTenantInactive(t *testing.T, client *wvt.Client, className, tenantName string) {
+	gotTenants, err := client.Schema().TenantsGetter().
+		WithClassName(className).
+		Do(context.Background())
+	require.Nil(t, err)
+	require.NotEmpty(t, gotTenants)
+
+	byName := fixtures.Tenants(gotTenants).ByName(tenantName)
+	require.NotNil(t, byName)
+	require.Equal(t, models.TenantActivityStatusCOLD, byName.ActivityStatus)
+}
+
+func assertActiveTenantObjects(t *testing.T, client *wvt.Client, className, tenantName string, expectedIds []string) {
+	objects, err := client.Data().ObjectsGetter().
+		WithClassName(className).
+		WithTenant(tenantName).
+		Do(context.Background())
+
+	require.Nil(t, err)
+	require.NotNil(t, objects)
+	require.Len(t, objects, len(expectedIds))
+
+	ids := make([]string, len(objects))
+	for i, object := range objects {
+		ids[i] = string(object.ID)
+	}
+	assert.ElementsMatch(t, expectedIds, ids)
+}
+
+func assertInactiveTenantObjects(t *testing.T, client *wvt.Client, className, tenantName string) {
+	// Data objects in Weaviate are eventually consistent, therefore we have to add some sleep time
+	// to make sure that the tenant was deactivate in all nodes
+	// see docs: https://github.com/weaviate/weaviate-io/blob/main/developers/weaviate/concepts/replication-architecture/consistency.md#data-objects
+	assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+		objects, err := client.Data().ObjectsGetter().
+			WithClassName(className).
+			WithTenant(tenantName).
+			Do(context.Background())
+
+		assert.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "tenant not active")
+		assert.Nil(t, objects)
+	}, 5*time.Second, 1*time.Second, "tenant was active, expected to be inactive")
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/multi_tenancy_tests/batch_reference_test.go

@@ -0,0 +1,1589 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package multi_tenancy_tests
+
+import (
+	"context"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "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"
+)
+
+func TestBatchReferenceCreate_MultiTenancy(t *testing.T) {
+	client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+	require.Nil(t, err)
+
+	cleanup := func() {
+		err := client.Schema().AllDeleter().Do(context.Background())
+		require.Nil(t, err)
+	}
+
+	testCases := []struct {
+		name                string
+		explicitTargetClass bool
+	}{
+		{
+			name:                "explicit target class",
+			explicitTargetClass: true,
+		},
+		{
+			name:                "auto detected target class",
+			explicitTargetClass: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Run("creates references between MT classes", func(t *testing.T) {
+				defer cleanup()
+
+				tenants := fixtures.Tenants{
+					{Name: "tenantNo1"},
+					{Name: "tenantNo2"},
+				}
+				soupIds := fixtures.IdsByClass["Soup"]
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenants...)
+				fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenants...)
+				fixtures.CreateDataPizzaForTenants(t, client, tenants.Names()...)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, tenant := range tenants {
+					for _, soupId := range soupIds {
+						for _, pizzaId := range pizzaIds {
+							rpb := client.Batch().ReferencePayloadBuilder().
+								WithFromClassName("Soup").
+								WithFromRefProp("relatedToPizza").
+								WithFromID(soupId).
+								WithToID(pizzaId).
+								WithTenant(tenant.Name)
+
+							if tc.explicitTargetClass {
+								rpb.WithToClassName("Pizza")
+							}
+
+							references = append(references, rpb.Payload())
+						}
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "SUCCESS", *resp[i].Result.Status)
+					assert.Nil(t, resp[i].Result.Errors)
+				}
+
+				t.Run("verify created", func(t *testing.T) {
+					for _, tenant := range tenants {
+						for _, soupId := range soupIds {
+							objects, err := client.Data().ObjectsGetter().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenant.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							require.NotNil(t, objects)
+							require.Len(t, objects, 1)
+							assert.Len(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"].([]interface{}),
+								len(pizzaIds))
+						}
+					}
+				})
+
+				t.Run("verify graphql search", func(t *testing.T) {
+					for _, tenant := range tenants {
+						resp, err := client.GraphQL().Get().
+							WithClassName("Soup").
+							WithTenant(tenant.Name).
+							WithFields(graphql.Field{
+								Name: "_additional", Fields: []graphql.Field{{Name: "id"}},
+							}).
+							WithWhere(filters.Where().
+								WithPath([]string{"relatedToPizza", "Pizza", "name"}).
+								WithOperator(filters.Equal).
+								WithValueString("Quattro Formaggi")).
+							Do(context.Background())
+
+						require.NoError(t, err)
+						assertGraphqlGetIds(t, resp, "Soup", soupIds)
+					}
+				})
+			})
+
+			t.Run("fails creating references between MT classes without tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenants := fixtures.Tenants{
+					{Name: "tenantNo1"},
+					{Name: "tenantNo2"},
+				}
+				soupIds := fixtures.IdsByClass["Soup"]
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenants...)
+				fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenants...)
+				fixtures.CreateDataPizzaForTenants(t, client, tenants.Names()...)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "has multi-tenancy enabled, but request was without tenant")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, tenant := range tenants {
+						for _, soupId := range soupIds {
+							objects, err := client.Data().ObjectsGetter().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenant.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							require.NotNil(t, objects)
+							require.Len(t, objects, 1)
+							assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+						}
+					}
+				})
+			})
+
+			t.Run("fails creating references between MT classes with non existent tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenants := fixtures.Tenants{
+					{Name: "tenantNo1"},
+					{Name: "tenantNo2"},
+				}
+				soupIds := fixtures.IdsByClass["Soup"]
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenants...)
+				fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenants...)
+				fixtures.CreateDataPizzaForTenants(t, client, tenants.Names()...)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant("nonExistentTenant")
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "tenant not found")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, tenant := range tenants {
+						for _, soupId := range soupIds {
+							objects, err := client.Data().ObjectsGetter().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenant.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							require.NotNil(t, objects)
+							require.Len(t, objects, 1)
+							assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+						}
+					}
+				})
+			})
+
+			t.Run("fails creating references between MT classes with different existing tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenants := fixtures.Tenants{
+					{Name: "tenantNo1"},
+					{Name: "tenantNo2"},
+				}
+				soupIds := fixtures.IdsByClass["Soup"]
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenants...)
+				fixtures.CreateDataSoupForTenants(t, client, tenants[0].Name)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenants...)
+				fixtures.CreateDataPizzaForTenants(t, client, tenants[0].Name)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant(tenants[1].Name)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "not found for tenant")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenants[0].Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenants[1].Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						assert.False(t, exists)
+					}
+
+					for _, pizzaId := range pizzaIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Pizza").
+							WithID(pizzaId).
+							WithTenant(tenants[1].Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						assert.False(t, exists)
+					}
+				})
+			})
+
+			t.Run("fails creating references between MT classes and different tenants", func(t *testing.T) {
+				tenantPizza := models.Tenant{Name: "tenantPizza"}
+				tenantSoup := models.Tenant{Name: "tenantSoup"}
+				soupIds := fixtures.IdsByClass["Soup"]
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+
+				t.Run("with SRC tenant (common tenants)", func(t *testing.T) {
+					defer cleanup()
+
+					fixtures.CreateSchemaSoupForTenants(t, client)
+					fixtures.CreateTenantsSoup(t, client, tenantPizza, tenantSoup)
+					fixtures.CreateDataSoupForTenants(t, client, tenantSoup.Name)
+
+					fixtures.CreateSchemaPizzaForTenants(t, client)
+					fixtures.CreateTenantsPizza(t, client, tenantPizza, tenantSoup)
+					fixtures.CreateDataPizzaForTenants(t, client, tenantPizza.Name)
+
+					t.Run("create ref property", func(t *testing.T) {
+						err := client.Schema().PropertyCreator().
+							WithClassName("Soup").
+							WithProperty(&models.Property{
+								Name:     "relatedToPizza",
+								DataType: []string{"Pizza"},
+							}).
+							Do(context.Background())
+
+						require.Nil(t, err)
+					})
+
+					references := []*models.BatchReference{}
+					for _, soupId := range soupIds {
+						for _, pizzaId := range pizzaIds {
+							rpb := client.Batch().ReferencePayloadBuilder().
+								WithFromClassName("Soup").
+								WithFromRefProp("relatedToPizza").
+								WithFromID(soupId).
+								WithToID(pizzaId).
+								WithTenant(tenantSoup.Name) // SRC tenant
+
+							if tc.explicitTargetClass {
+								rpb.WithToClassName("Pizza")
+							}
+
+							references = append(references, rpb.Payload())
+						}
+					}
+
+					resp, err := client.Batch().ReferencesBatcher().
+						WithReferences(references...).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.NotNil(t, resp)
+					assert.Len(t, resp, len(references))
+					for i := range resp {
+						require.NotNil(t, resp[i].Result)
+						require.NotNil(t, resp[i].Result.Status)
+						assert.Equal(t, "FAILED", *resp[i].Result.Status)
+						require.NotNil(t, resp[i].Result.Errors)
+						require.Len(t, resp[i].Result.Errors.Error, 1)
+						assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "not found for tenant")
+					}
+
+					t.Run("verify not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							objects, err := client.Data().ObjectsGetter().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							require.NotNil(t, objects)
+							require.Len(t, objects, 1)
+							assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+						}
+					})
+
+					t.Run("verify new objects not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantPizza.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							assert.False(t, exists)
+						}
+
+						for _, pizzaId := range pizzaIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Pizza").
+								WithID(pizzaId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							assert.False(t, exists)
+						}
+					})
+				})
+
+				t.Run("with SRC tenant (separate tenants)", func(t *testing.T) {
+					defer cleanup()
+
+					fixtures.CreateSchemaSoupForTenants(t, client)
+					fixtures.CreateTenantsSoup(t, client, tenantSoup)
+					fixtures.CreateDataSoupForTenants(t, client, tenantSoup.Name)
+
+					fixtures.CreateSchemaPizzaForTenants(t, client)
+					fixtures.CreateTenantsPizza(t, client, tenantPizza)
+					fixtures.CreateDataPizzaForTenants(t, client, tenantPizza.Name)
+
+					t.Run("create ref property", func(t *testing.T) {
+						err := client.Schema().PropertyCreator().
+							WithClassName("Soup").
+							WithProperty(&models.Property{
+								Name:     "relatedToPizza",
+								DataType: []string{"Pizza"},
+							}).
+							Do(context.Background())
+
+						require.Nil(t, err)
+					})
+
+					references := []*models.BatchReference{}
+					for _, soupId := range soupIds {
+						for _, pizzaId := range pizzaIds {
+							rpb := client.Batch().ReferencePayloadBuilder().
+								WithFromClassName("Soup").
+								WithFromRefProp("relatedToPizza").
+								WithFromID(soupId).
+								WithToID(pizzaId).
+								WithTenant(tenantSoup.Name) // SRC tenant
+
+							if tc.explicitTargetClass {
+								rpb.WithToClassName("Pizza")
+							}
+
+							references = append(references, rpb.Payload())
+						}
+					}
+
+					resp, err := client.Batch().ReferencesBatcher().
+						WithReferences(references...).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.NotNil(t, resp)
+					assert.Len(t, resp, len(references))
+					for i := range resp {
+						require.NotNil(t, resp[i].Result)
+						require.NotNil(t, resp[i].Result.Status)
+						assert.Equal(t, "FAILED", *resp[i].Result.Status)
+						require.NotNil(t, resp[i].Result.Errors)
+						require.Len(t, resp[i].Result.Errors.Error, 1)
+						assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "tenant not found")
+					}
+
+					t.Run("verify not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							objects, err := client.Data().ObjectsGetter().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							require.NotNil(t, objects)
+							require.Len(t, objects, 1)
+							assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+						}
+					})
+
+					t.Run("verify new objects not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantPizza.Name).
+								Do(context.Background())
+
+							require.NotNil(t, err)
+							assert.False(t, exists)
+						}
+
+						for _, pizzaId := range pizzaIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Pizza").
+								WithID(pizzaId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.NotNil(t, err)
+							assert.False(t, exists)
+						}
+					})
+				})
+
+				t.Run("with DEST tenant (common tenants)", func(t *testing.T) {
+					defer cleanup()
+
+					fixtures.CreateSchemaSoupForTenants(t, client)
+					fixtures.CreateTenantsSoup(t, client, tenantPizza, tenantSoup)
+					fixtures.CreateDataSoupForTenants(t, client, tenantSoup.Name)
+
+					fixtures.CreateSchemaPizzaForTenants(t, client)
+					fixtures.CreateTenantsPizza(t, client, tenantPizza, tenantSoup)
+					fixtures.CreateDataPizzaForTenants(t, client, tenantPizza.Name)
+
+					t.Run("create ref property", func(t *testing.T) {
+						err := client.Schema().PropertyCreator().
+							WithClassName("Soup").
+							WithProperty(&models.Property{
+								Name:     "relatedToPizza",
+								DataType: []string{"Pizza"},
+							}).
+							Do(context.Background())
+
+						require.Nil(t, err)
+					})
+
+					references := []*models.BatchReference{}
+					for _, soupId := range soupIds {
+						for _, pizzaId := range pizzaIds {
+							rpb := client.Batch().ReferencePayloadBuilder().
+								WithFromClassName("Soup").
+								WithFromRefProp("relatedToPizza").
+								WithFromID(soupId).
+								WithToID(pizzaId).
+								WithTenant(tenantPizza.Name) // DEST tenant
+
+							if tc.explicitTargetClass {
+								rpb.WithToClassName("Pizza")
+							}
+
+							references = append(references, rpb.Payload())
+						}
+					}
+
+					resp, err := client.Batch().ReferencesBatcher().
+						WithReferences(references...).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.NotNil(t, resp)
+					assert.Len(t, resp, len(references))
+					for i := range resp {
+						require.NotNil(t, resp[i].Result)
+						require.NotNil(t, resp[i].Result.Status)
+						assert.Equal(t, "FAILED", *resp[i].Result.Status)
+						require.NotNil(t, resp[i].Result.Errors)
+						require.Len(t, resp[i].Result.Errors.Error, 1)
+						assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "not found for tenant")
+					}
+
+					t.Run("verify not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							objects, err := client.Data().ObjectsGetter().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							require.NotNil(t, objects)
+							require.Len(t, objects, 1)
+							assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+						}
+					})
+
+					t.Run("verify new objects not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantPizza.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							assert.False(t, exists)
+						}
+
+						for _, pizzaId := range pizzaIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Pizza").
+								WithID(pizzaId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							assert.False(t, exists)
+						}
+					})
+				})
+
+				t.Run("with DEST tenant (separate tenants)", func(t *testing.T) {
+					defer cleanup()
+
+					fixtures.CreateSchemaSoupForTenants(t, client)
+					fixtures.CreateTenantsSoup(t, client, tenantSoup)
+					fixtures.CreateDataSoupForTenants(t, client, tenantSoup.Name)
+
+					fixtures.CreateSchemaPizzaForTenants(t, client)
+					fixtures.CreateTenantsPizza(t, client, tenantPizza)
+					fixtures.CreateDataPizzaForTenants(t, client, tenantPizza.Name)
+
+					t.Run("create ref property", func(t *testing.T) {
+						err := client.Schema().PropertyCreator().
+							WithClassName("Soup").
+							WithProperty(&models.Property{
+								Name:     "relatedToPizza",
+								DataType: []string{"Pizza"},
+							}).
+							Do(context.Background())
+
+						require.Nil(t, err)
+					})
+
+					references := []*models.BatchReference{}
+					for _, soupId := range soupIds {
+						for _, pizzaId := range pizzaIds {
+							rpb := client.Batch().ReferencePayloadBuilder().
+								WithFromClassName("Soup").
+								WithFromRefProp("relatedToPizza").
+								WithFromID(soupId).
+								WithToID(pizzaId).
+								WithTenant(tenantPizza.Name) // DEST tenant
+
+							if tc.explicitTargetClass {
+								rpb.WithToClassName("Pizza")
+							}
+
+							references = append(references, rpb.Payload())
+						}
+					}
+
+					resp, err := client.Batch().ReferencesBatcher().
+						WithReferences(references...).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.NotNil(t, resp)
+					assert.Len(t, resp, len(references))
+					for i := range resp {
+						require.NotNil(t, resp[i].Result)
+						require.NotNil(t, resp[i].Result.Status)
+						assert.Equal(t, "FAILED", *resp[i].Result.Status)
+						require.NotNil(t, resp[i].Result.Errors)
+						require.Len(t, resp[i].Result.Errors.Error, 1)
+						assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "tenant not found")
+					}
+
+					t.Run("verify not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							objects, err := client.Data().ObjectsGetter().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.Nil(t, err)
+							require.NotNil(t, objects)
+							require.Len(t, objects, 1)
+							assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+						}
+					})
+
+					t.Run("verify new objects not created", func(t *testing.T) {
+						for _, soupId := range soupIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenantPizza.Name).
+								Do(context.Background())
+
+							require.NotNil(t, err)
+							assert.False(t, exists)
+						}
+
+						for _, pizzaId := range pizzaIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Pizza").
+								WithID(pizzaId).
+								WithTenant(tenantSoup.Name).
+								Do(context.Background())
+
+							require.NotNil(t, err)
+							assert.False(t, exists)
+						}
+					})
+				})
+			})
+
+			t.Run("creates references between MT and non-MT classes", func(t *testing.T) {
+				defer cleanup()
+
+				tenantSoup := models.Tenant{Name: "tenantSoup"}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenantSoup)
+				fixtures.CreateDataSoupForTenants(t, client, tenantSoup.Name)
+
+				fixtures.CreateSchemaPizza(t, client)
+				fixtures.CreateDataPizza(t, client)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant(tenantSoup.Name)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "SUCCESS", *resp[i].Result.Status)
+					assert.Nil(t, resp[i].Result.Errors)
+				}
+
+				t.Run("verify created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenantSoup.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Len(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"].([]interface{}),
+							len(pizzaIds))
+					}
+				})
+
+				t.Run("verify graphql search", func(t *testing.T) {
+					resp, err := client.GraphQL().Get().
+						WithClassName("Soup").
+						WithTenant(tenantSoup.Name).
+						WithFields(graphql.Field{
+							Name: "_additional", Fields: []graphql.Field{{Name: "id"}},
+						}).
+						WithWhere(filters.Where().
+							WithPath([]string{"relatedToPizza", "Pizza", "name"}).
+							WithOperator(filters.Equal).
+							WithValueString("Quattro Formaggi")).
+						Do(context.Background())
+
+					require.NoError(t, err)
+					assertGraphqlGetIds(t, resp, "Soup", soupIds)
+				})
+			})
+
+			t.Run("fails creating references between MT and non-MT classes without tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenantSoup := models.Tenant{Name: "tenantSoup"}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenantSoup)
+				fixtures.CreateDataSoupForTenants(t, client, tenantSoup.Name)
+
+				fixtures.CreateSchemaPizza(t, client)
+				fixtures.CreateDataPizza(t, client)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "has multi-tenancy enabled, but request was without tenant")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenantSoup.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+
+					for _, pizzaId := range pizzaIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Pizza").
+							WithID(pizzaId).
+							WithTenant(tenantSoup.Name).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+				})
+			})
+
+			t.Run("fails creating references between MT and non-MT classes with non existent tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenantSoup := models.Tenant{Name: "tenantSoup"}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenantSoup)
+				fixtures.CreateDataSoupForTenants(t, client, tenantSoup.Name)
+
+				fixtures.CreateSchemaPizza(t, client)
+				fixtures.CreateDataPizza(t, client)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant("nonExistentTenant")
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "tenant not found")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenantSoup.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+
+					for _, pizzaId := range pizzaIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Pizza").
+							WithID(pizzaId).
+							WithTenant(tenantSoup.Name).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+				})
+			})
+
+			t.Run("fails creating references between MT and non-MT classes with different existing tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenants := fixtures.Tenants{
+					{Name: "tenantNo1"},
+					{Name: "tenantNo2"},
+				}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoupForTenants(t, client)
+				fixtures.CreateTenantsSoup(t, client, tenants...)
+				fixtures.CreateDataSoupForTenants(t, client, tenants[0].Name)
+
+				fixtures.CreateSchemaPizza(t, client)
+				fixtures.CreateDataPizza(t, client)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant(tenants[1].Name)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "not found for tenant")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenants[0].Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenants[1].Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						assert.False(t, exists)
+					}
+
+					for _, tenant := range tenants {
+						for _, pizzaId := range pizzaIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Pizza").
+								WithID(pizzaId).
+								WithTenant(tenant.Name).
+								Do(context.Background())
+
+							require.NotNil(t, err)
+							assert.False(t, exists)
+						}
+					}
+				})
+			})
+
+			t.Run("fails creating references between non-MT and MT classes", func(t *testing.T) {
+				defer cleanup()
+
+				tenantPizza := models.Tenant{Name: "tenantPizza"}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoup(t, client)
+				fixtures.CreateDataSoup(t, client)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenantPizza)
+				fixtures.CreateDataPizzaForTenants(t, client, tenantPizza.Name)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant(tenantPizza.Name)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "cannot reference a multi-tenant enabled class from a non multi-tenant enabled class")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenantPizza.Name).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+				})
+			})
+
+			t.Run("fails creating references between non-MT and MT classes without tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenantPizza := models.Tenant{Name: "tenantPizza"}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoup(t, client)
+				fixtures.CreateDataSoup(t, client)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenantPizza)
+				fixtures.CreateDataPizzaForTenants(t, client, tenantPizza.Name)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "cannot reference a multi-tenant enabled class from a non multi-tenant enabled class")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenantPizza.Name).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+				})
+			})
+
+			t.Run("fails creating references between non-MT and MT classes with non existent tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenantPizza := models.Tenant{Name: "tenantPizza"}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoup(t, client)
+				fixtures.CreateDataSoup(t, client)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenantPizza)
+				fixtures.CreateDataPizzaForTenants(t, client, tenantPizza.Name)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant("nonExistentTenant")
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "cannot reference a multi-tenant enabled class from a non multi-tenant enabled class")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(soupId).
+							WithTenant(tenantPizza.Name).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+				})
+			})
+
+			t.Run("fails creating references between non-MT and MT classes with different existing tenant", func(t *testing.T) {
+				defer cleanup()
+
+				tenants := fixtures.Tenants{
+					{Name: "tenantNo1"},
+					{Name: "tenantNo2"},
+				}
+				pizzaIds := fixtures.IdsByClass["Pizza"]
+				soupIds := fixtures.IdsByClass["Soup"]
+
+				fixtures.CreateSchemaSoup(t, client)
+				fixtures.CreateDataSoup(t, client)
+
+				fixtures.CreateSchemaPizzaForTenants(t, client)
+				fixtures.CreateTenantsPizza(t, client, tenants...)
+				fixtures.CreateDataPizzaForTenants(t, client, tenants[0].Name)
+
+				t.Run("create ref property", func(t *testing.T) {
+					err := client.Schema().PropertyCreator().
+						WithClassName("Soup").
+						WithProperty(&models.Property{
+							Name:     "relatedToPizza",
+							DataType: []string{"Pizza"},
+						}).
+						Do(context.Background())
+
+					require.Nil(t, err)
+				})
+
+				references := []*models.BatchReference{}
+				for _, soupId := range soupIds {
+					for _, pizzaId := range pizzaIds {
+						rpb := client.Batch().ReferencePayloadBuilder().
+							WithFromClassName("Soup").
+							WithFromRefProp("relatedToPizza").
+							WithFromID(soupId).
+							WithToID(pizzaId).
+							WithTenant(tenants[1].Name)
+
+						if tc.explicitTargetClass {
+							rpb.WithToClassName("Pizza")
+						}
+
+						references = append(references, rpb.Payload())
+					}
+				}
+
+				resp, err := client.Batch().ReferencesBatcher().
+					WithReferences(references...).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				assert.Len(t, resp, len(references))
+				for i := range resp {
+					require.NotNil(t, resp[i].Result)
+					require.NotNil(t, resp[i].Result.Status)
+					assert.Equal(t, "FAILED", *resp[i].Result.Status)
+					require.NotNil(t, resp[i].Result.Errors)
+					require.Len(t, resp[i].Result.Errors.Error, 1)
+					assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "cannot reference a multi-tenant enabled class from a non multi-tenant enabled class")
+				}
+
+				t.Run("verify not created", func(t *testing.T) {
+					for _, soupId := range soupIds {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName("Soup").
+							WithID(soupId).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Nil(t, objects[0].Properties.(map[string]interface{})["relatedToPizza"])
+					}
+				})
+
+				t.Run("verify new objects not created", func(t *testing.T) {
+					for _, tenant := range tenants {
+						for _, soupId := range soupIds {
+							exists, err := client.Data().Checker().
+								WithClassName("Soup").
+								WithID(soupId).
+								WithTenant(tenant.Name).
+								Do(context.Background())
+
+							require.NotNil(t, err)
+							assert.False(t, exists)
+						}
+					}
+
+					for _, pizzaId := range pizzaIds {
+						exists, err := client.Data().Checker().
+							WithClassName("Soup").
+							WithID(pizzaId).
+							WithTenant(tenants[1].Name).
+							Do(context.Background())
+
+						require.NotNil(t, err)
+						assert.False(t, exists)
+					}
+				})
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/multi_tenancy_tests/batch_test.go

@@ -0,0 +1,729 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package multi_tenancy_tests
+
+import (
+	"context"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/fault"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/filters"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func TestBatchCreate_MultiTenancy(t *testing.T) {
+	client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+	require.Nil(t, err)
+
+	cleanup := func() {
+		err := client.Schema().AllDeleter().Do(context.Background())
+		require.Nil(t, err)
+	}
+
+	t.Run("creates objects of MT class", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaPizzaForTenants(t, client)
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsPizza(t, client, tenants...)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+
+		for _, tenant := range tenants {
+			resp, err := client.Batch().ObjectsBatcher().
+				WithObjects(
+					&models.Object{
+						Class: "Pizza",
+						ID:    fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+						Properties: map[string]interface{}{
+							"name":        "Quattro Formaggi",
+							"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+							"price":       float32(1.1),
+							"best_before": "2022-05-03T12:04:40+02:00",
+						},
+						Tenant: tenant.Name,
+					},
+					&models.Object{
+						Class: "Pizza",
+						ID:    fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+						Properties: map[string]interface{}{
+							"name":        "Frutti di Mare",
+							"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+							"price":       float32(1.2),
+							"best_before": "2022-05-05T07:16:30+02:00",
+						},
+						Tenant: tenant.Name,
+					},
+					&models.Object{
+						Class: "Soup",
+						ID:    fixtures.SOUP_CHICKENSOUP_ID,
+						Properties: map[string]interface{}{
+							"name":        "ChickenSoup",
+							"description": "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+							"price":       float32(2.1),
+						},
+						Tenant: tenant.Name,
+					},
+					&models.Object{
+						Class: "Soup",
+						ID:    fixtures.SOUP_BEAUTIFUL_ID,
+						Properties: map[string]interface{}{
+							"name":        "Beautiful",
+							"description": "Putting the game of letter soups to a whole new level.",
+							"price":       float32(2.2),
+						},
+						Tenant: tenant.Name,
+					}).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, resp)
+			require.Len(t, resp, 4)
+
+			ids := make([]string, len(resp))
+			for i := range resp {
+				require.NotNil(t, resp[i])
+				require.NotNil(t, resp[i].Result)
+				require.NotNil(t, resp[i].Result.Status)
+				assert.Equal(t, "SUCCESS", *resp[i].Result.Status)
+				assert.Equal(t, tenant.Name, resp[i].Tenant)
+
+				ids[i] = resp[i].ID.String()
+			}
+			assert.ElementsMatch(t, ids, []string{
+				fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+				fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+				fixtures.SOUP_CHICKENSOUP_ID,
+				fixtures.SOUP_BEAUTIFUL_ID,
+			})
+		}
+
+		t.Run("verify created", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for id, className := range map[string]string{
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID: "Pizza",
+					fixtures.PIZZA_FRUTTI_DI_MARE_ID:   "Pizza",
+					fixtures.SOUP_CHICKENSOUP_ID:       "Soup",
+					fixtures.SOUP_BEAUTIFUL_ID:         "Soup",
+				} {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.True(t, exists)
+				}
+			}
+		})
+	})
+
+	t.Run("fails creating objects of MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaPizzaForTenants(t, client)
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsPizza(t, client, tenants...)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+
+		resp, err := client.Batch().ObjectsBatcher().
+			WithObjects(
+				&models.Object{
+					Class: "Pizza",
+					ID:    fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+					Properties: map[string]interface{}{
+						"name":        "Quattro Formaggi",
+						"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+						"price":       float32(1.1),
+						"best_before": "2022-05-03T12:04:40+02:00",
+					},
+				},
+				&models.Object{
+					Class: "Pizza",
+					ID:    fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+					Properties: map[string]interface{}{
+						"name":        "Frutti di Mare",
+						"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+						"price":       float32(1.2),
+						"best_before": "2022-05-05T07:16:30+02:00",
+					},
+				},
+				&models.Object{
+					Class: "Soup",
+					ID:    fixtures.SOUP_CHICKENSOUP_ID,
+					Properties: map[string]interface{}{
+						"name":        "ChickenSoup",
+						"description": "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+						"price":       float32(2.1),
+					},
+				},
+				&models.Object{
+					Class: "Soup",
+					ID:    fixtures.SOUP_BEAUTIFUL_ID,
+					Properties: map[string]interface{}{
+						"name":        "Beautiful",
+						"description": "Putting the game of letter soups to a whole new level.",
+						"price":       float32(2.2),
+					},
+				}).
+			Do(context.Background())
+
+		require.Nil(t, err)
+		require.NotNil(t, resp)
+		require.Len(t, resp, 4)
+
+		for i := range resp {
+			require.NotNil(t, resp[i])
+			require.NotNil(t, resp[i].Result)
+			require.NotNil(t, resp[i].Result.Status)
+			assert.Equal(t, "FAILED", *resp[i].Result.Status)
+			require.NotNil(t, resp[i].Result.Errors)
+			require.NotNil(t, resp[i].Result.Errors.Error)
+			require.Len(t, resp[i].Result.Errors.Error, 1)
+			assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "has multi-tenancy enabled, but request was without tenant")
+			assert.Empty(t, resp[i].Tenant)
+		}
+
+		t.Run("verify not created", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for id, className := range map[string]string{
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID: "Pizza",
+					fixtures.PIZZA_FRUTTI_DI_MARE_ID:   "Pizza",
+					fixtures.SOUP_CHICKENSOUP_ID:       "Soup",
+					fixtures.SOUP_BEAUTIFUL_ID:         "Soup",
+				} {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.False(t, exists)
+				}
+			}
+		})
+	})
+
+	t.Run("fails creating objects of MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaPizzaForTenants(t, client)
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsPizza(t, client, tenants...)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+
+		resp, err := client.Batch().ObjectsBatcher().
+			WithObjects(
+				&models.Object{
+					Class: "Pizza",
+					ID:    fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+					Properties: map[string]interface{}{
+						"name":        "Quattro Formaggi",
+						"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+						"price":       float32(1.1),
+						"best_before": "2022-05-03T12:04:40+02:00",
+					},
+					Tenant: "nonExistentTenant",
+				},
+				&models.Object{
+					Class: "Pizza",
+					ID:    fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+					Properties: map[string]interface{}{
+						"name":        "Frutti di Mare",
+						"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+						"price":       float32(1.2),
+						"best_before": "2022-05-05T07:16:30+02:00",
+					},
+					Tenant: "nonExistentTenant",
+				},
+				&models.Object{
+					Class: "Soup",
+					ID:    fixtures.SOUP_CHICKENSOUP_ID,
+					Properties: map[string]interface{}{
+						"name":        "ChickenSoup",
+						"description": "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+						"price":       float32(2.1),
+					},
+					Tenant: "nonExistentTenant",
+				},
+				&models.Object{
+					Class: "Soup",
+					ID:    fixtures.SOUP_BEAUTIFUL_ID,
+					Properties: map[string]interface{}{
+						"name":        "Beautiful",
+						"description": "Putting the game of letter soups to a whole new level.",
+						"price":       float32(2.2),
+					},
+					Tenant: "nonExistentTenant",
+				}).
+			Do(context.Background())
+
+		require.Nil(t, err)
+		require.NotNil(t, resp)
+		assert.Len(t, resp, 4)
+		for i := range resp {
+			require.NotNil(t, resp[i])
+			require.NotNil(t, resp[i].Result)
+			require.NotNil(t, resp[i].Result.Status)
+			assert.Equal(t, "FAILED", *resp[i].Result.Status)
+			require.NotNil(t, resp[i].Result.Errors)
+			require.NotNil(t, resp[i].Result.Errors.Error)
+			require.Len(t, resp[i].Result.Errors.Error, 1)
+			assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "tenant not found")
+			assert.Equal(t, "nonExistentTenant", resp[i].Tenant)
+		}
+
+		t.Run("verify not created", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for id, className := range map[string]string{
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID: "Pizza",
+					fixtures.PIZZA_FRUTTI_DI_MARE_ID:   "Pizza",
+					fixtures.SOUP_CHICKENSOUP_ID:       "Soup",
+					fixtures.SOUP_BEAUTIFUL_ID:         "Soup",
+				} {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.False(t, exists)
+				}
+			}
+		})
+	})
+
+	t.Run("fails creating objects of non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaPizza(t, client)
+		fixtures.CreateSchemaSoup(t, client)
+
+		for _, tenant := range tenants {
+			resp, err := client.Batch().ObjectsBatcher().
+				WithObjects(
+					&models.Object{
+						Class: "Pizza",
+						ID:    fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+						Properties: map[string]interface{}{
+							"name":        "Quattro Formaggi",
+							"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+							"price":       float32(1.1),
+							"best_before": "2022-05-03T12:04:40+02:00",
+						},
+						Tenant: tenant.Name,
+					},
+					&models.Object{
+						Class: "Pizza",
+						ID:    fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+						Properties: map[string]interface{}{
+							"name":        "Frutti di Mare",
+							"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+							"price":       float32(1.2),
+							"best_before": "2022-05-05T07:16:30+02:00",
+						},
+						Tenant: tenant.Name,
+					},
+					&models.Object{
+						Class: "Soup",
+						ID:    fixtures.SOUP_CHICKENSOUP_ID,
+						Properties: map[string]interface{}{
+							"name":        "ChickenSoup",
+							"description": "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+							"price":       float32(2.1),
+						},
+						Tenant: tenant.Name,
+					},
+					&models.Object{
+						Class: "Soup",
+						ID:    fixtures.SOUP_BEAUTIFUL_ID,
+						Properties: map[string]interface{}{
+							"name":        "Beautiful",
+							"description": "Putting the game of letter soups to a whole new level.",
+							"price":       float32(2.2),
+						},
+						Tenant: tenant.Name,
+					}).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, resp)
+			require.Len(t, resp, 4)
+			for i := range resp {
+				require.NotNil(t, resp[i])
+				require.NotNil(t, resp[i].Result)
+				require.NotNil(t, resp[i].Result.Status)
+				assert.Equal(t, "FAILED", *resp[i].Result.Status)
+				require.NotNil(t, resp[i].Result.Errors)
+				require.NotNil(t, resp[i].Result.Errors.Error)
+				require.Len(t, resp[i].Result.Errors.Error, 1)
+				assert.Contains(t, resp[i].Result.Errors.Error[0].Message, "has multi-tenancy disabled, but request was with tenant")
+				assert.Equal(t, tenant.Name, resp[i].Tenant)
+			}
+		}
+
+		t.Run("verify not created", func(t *testing.T) {
+			for id, className := range map[string]string{
+				fixtures.PIZZA_QUATTRO_FORMAGGI_ID: "Pizza",
+				fixtures.PIZZA_FRUTTI_DI_MARE_ID:   "Pizza",
+				fixtures.SOUP_CHICKENSOUP_ID:       "Soup",
+				fixtures.SOUP_BEAUTIFUL_ID:         "Soup",
+			} {
+				exists, err := client.Data().Checker().
+					WithID(id).
+					WithClassName(className).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.False(t, exists)
+			}
+		})
+	})
+}
+
+func TestBatchDelete_MultiTenancy(t *testing.T) {
+	client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+	require.Nil(t, err)
+
+	cleanup := func() {
+		err := client.Schema().AllDeleter().Do(context.Background())
+		require.Nil(t, err)
+	}
+
+	t.Run("deletes objects from MT class", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for _, tenant := range tenants {
+			for className, ids := range fixtures.IdsByClass {
+				resp, err := client.Batch().ObjectsBatchDeleter().
+					WithClassName(className).
+					WithWhere(filters.Where().
+						WithOperator(filters.Like).
+						WithPath([]string{"name"}).
+						WithValueText("*")).
+					WithOutput("minimal").
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Results)
+				assert.Equal(t, int64(len(ids)), resp.Results.Matches)
+				assert.Equal(t, int64(len(ids)), resp.Results.Successful)
+			}
+		}
+
+		t.Run("verify deleted", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for className, ids := range fixtures.IdsByClass {
+					for _, id := range ids {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.False(t, exists)
+					}
+				}
+			}
+		})
+	})
+
+	t.Run("fails deleting objects from MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className := range fixtures.IdsByClass {
+			resp, err := client.Batch().ObjectsBatchDeleter().
+				WithClassName(className).
+				WithWhere(filters.Where().
+					WithOperator(filters.Like).
+					WithPath([]string{"name"}).
+					WithValueText("*")).
+				WithOutput("minimal").
+				Do(context.Background())
+
+			require.NotNil(t, err)
+			clientErr := err.(*fault.WeaviateClientError)
+			assert.Equal(t, 422, clientErr.StatusCode)
+			assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+			require.Nil(t, resp)
+		}
+
+		t.Run("verify not deleted", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for className, ids := range fixtures.IdsByClass {
+					for _, id := range ids {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.True(t, exists)
+					}
+				}
+			}
+		})
+	})
+
+	t.Run("fails deleting objects from MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className := range fixtures.IdsByClass {
+			resp, err := client.Batch().ObjectsBatchDeleter().
+				WithClassName(className).
+				WithWhere(filters.Where().
+					WithOperator(filters.Like).
+					WithPath([]string{"name"}).
+					WithValueText("*")).
+				WithOutput("minimal").
+				WithTenant("nonExistentTenant").
+				Do(context.Background())
+
+			require.NotNil(t, err)
+			clientErr := err.(*fault.WeaviateClientError)
+			assert.Equal(t, 422, clientErr.StatusCode)
+			assert.Contains(t, clientErr.Msg, "tenant not found")
+			require.Nil(t, resp)
+		}
+
+		t.Run("verify not deleted", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for className, ids := range fixtures.IdsByClass {
+					for _, id := range ids {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.True(t, exists)
+					}
+				}
+			}
+		})
+	})
+
+	t.Run("fails deleting objects from non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		fixtures.CreateSchemaFood(t, client)
+		fixtures.CreateDataFood(t, client)
+
+		for className := range fixtures.IdsByClass {
+			resp, err := client.Batch().ObjectsBatchDeleter().
+				WithClassName(className).
+				WithWhere(filters.Where().
+					WithOperator(filters.Like).
+					WithPath([]string{"name"}).
+					WithValueText("*")).
+				WithOutput("minimal").
+				WithTenant("nonExistentTenant").
+				Do(context.Background())
+
+			require.NotNil(t, err)
+			clientErr := err.(*fault.WeaviateClientError)
+			assert.Equal(t, 422, clientErr.StatusCode)
+			assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+			require.Nil(t, resp)
+		}
+
+		t.Run("verify non deleted", func(t *testing.T) {
+			for className, ids := range fixtures.IdsByClass {
+				for _, id := range ids {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.True(t, exists)
+				}
+			}
+		})
+	})
+
+	t.Run("deletes objects from MT class by ref", func(t *testing.T) {
+		defer cleanup()
+
+		tenant1 := models.Tenant{Name: "tenantNo1"}
+		tenant2 := models.Tenant{Name: "tenantNo2"}
+		soupIdByTenantAndPizza := map[string]map[string]string{
+			tenant1.Name: {
+				fixtures.PIZZA_QUATTRO_FORMAGGI_ID: fixtures.SOUP_CHICKENSOUP_ID,
+				fixtures.PIZZA_FRUTTI_DI_MARE_ID:   fixtures.SOUP_CHICKENSOUP_ID,
+			},
+			tenant2.Name: {
+				fixtures.PIZZA_HAWAII_ID: fixtures.SOUP_BEAUTIFUL_ID,
+				fixtures.PIZZA_DOENER_ID: fixtures.SOUP_BEAUTIFUL_ID,
+			},
+		}
+
+		t.Run("add data", func(t *testing.T) {
+			fixtures.CreateSchemaPizzaForTenants(t, client)
+			fixtures.CreateTenantsPizza(t, client, tenant1, tenant2)
+			fixtures.CreateDataPizzaQuattroFormaggiForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaFruttiDiMareForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaHawaiiForTenants(t, client, tenant2.Name)
+			fixtures.CreateDataPizzaDoenerForTenants(t, client, tenant2.Name)
+
+			fixtures.CreateSchemaSoupForTenants(t, client)
+			fixtures.CreateTenantsSoup(t, client, tenant1, tenant2)
+			fixtures.CreateDataSoupChickenForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataSoupBeautifulForTenants(t, client, tenant2.Name)
+		})
+
+		t.Run("create ref property", func(t *testing.T) {
+			err := client.Schema().PropertyCreator().
+				WithClassName("Soup").
+				WithProperty(&models.Property{
+					Name:     "relatedToPizza",
+					DataType: []string{"Pizza"},
+				}).
+				Do(context.Background())
+
+			require.Nil(t, err)
+		})
+
+		t.Run("create refs", func(t *testing.T) {
+			references := []*models.BatchReference{}
+
+			for tenant, pizzaToSoup := range soupIdByTenantAndPizza {
+				for pizzaId, soupId := range pizzaToSoup {
+					rpb := client.Batch().ReferencePayloadBuilder().
+						WithFromClassName("Soup").
+						WithFromRefProp("relatedToPizza").
+						WithFromID(soupId).
+						WithToClassName("Pizza").
+						WithToID(pizzaId).
+						WithTenant(tenant)
+
+					references = append(references, rpb.Payload())
+				}
+			}
+
+			resp, err := client.Batch().ReferencesBatcher().
+				WithReferences(references...).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, resp)
+			assert.Len(t, resp, len(references))
+			for i := range resp {
+				require.NotNil(t, resp[i].Result)
+				assert.Nil(t, resp[i].Result.Errors)
+			}
+		})
+
+		for tenant, pizzaToSoup := range soupIdByTenantAndPizza {
+			i := 0
+			for pizzaId := range pizzaToSoup {
+				resp, err := client.Batch().ObjectsBatchDeleter().
+					WithClassName("Soup").
+					WithWhere(filters.Where().
+						WithOperator(filters.Like).
+						WithPath([]string{"relatedToPizza", "Pizza", "_id"}).
+						WithValueText(pizzaId)).
+					WithOutput("minimal").
+					WithTenant(tenant).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Results)
+
+				// single soup references two pizzas, so soup will be deleted only for 1st pizza
+				if i == 0 {
+					assert.Equal(t, int64(1), resp.Results.Matches)
+					assert.Equal(t, int64(1), resp.Results.Successful)
+				} else {
+					assert.Equal(t, int64(0), resp.Results.Matches)
+					assert.Equal(t, int64(0), resp.Results.Successful)
+				}
+				i++
+			}
+		}
+
+		t.Run("verify deleted", func(t *testing.T) {
+			for tenant, pizzaToSoup := range soupIdByTenantAndPizza {
+				for _, soupId := range pizzaToSoup {
+					exists, err := client.Data().Checker().
+						WithID(soupId).
+						WithClassName("Soup").
+						WithTenant(tenant).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.False(t, exists)
+				}
+			}
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/multi_tenancy_tests/data_test.go

@@ -0,0 +1,1382 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package multi_tenancy_tests
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/fault"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func TestData_MultiTenancy(t *testing.T) {
+	client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+	require.Nil(t, err)
+
+	cleanup := func() {
+		err := client.Schema().AllDeleter().Do(context.Background())
+		require.Nil(t, err)
+	}
+
+	t.Run("creates objects of MT class", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Pizza"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaPizzaForTenants(t, client)
+		fixtures.CreateTenantsPizza(t, client, tenants...)
+
+		for _, tenant := range tenants {
+			wrap, err := client.Data().Creator().
+				WithClassName(className).
+				WithID(fixtures.PIZZA_QUATTRO_FORMAGGI_ID).
+				WithProperties(map[string]interface{}{
+					"name":        "Quattro Formaggi",
+					"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+					"price":       float32(1.1),
+					"best_before": "2022-05-03T12:04:40+02:00",
+				}).
+				WithTenant(tenant.Name).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, wrap)
+			require.NotNil(t, wrap.Object)
+			assert.Equal(t, strfmt.UUID(fixtures.PIZZA_QUATTRO_FORMAGGI_ID), wrap.Object.ID)
+			assert.Equal(t, "Quattro Formaggi", wrap.Object.Properties.(map[string]interface{})["name"])
+			assert.Equal(t, tenant.Name, wrap.Object.Tenant)
+
+			wrap, err = client.Data().Creator().
+				WithClassName(className).
+				WithID(fixtures.PIZZA_FRUTTI_DI_MARE_ID).
+				WithProperties(map[string]interface{}{
+					"name":        "Frutti di Mare",
+					"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+					"price":       float32(1.2),
+					"best_before": "2022-05-05T07:16:30+02:00",
+				}).
+				WithTenant(tenant.Name).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, wrap)
+			require.NotNil(t, wrap.Object)
+			assert.Equal(t, strfmt.UUID(fixtures.PIZZA_FRUTTI_DI_MARE_ID), wrap.Object.ID)
+			assert.Equal(t, "Frutti di Mare", wrap.Object.Properties.(map[string]interface{})["name"])
+			assert.Equal(t, tenant.Name, wrap.Object.Tenant)
+		}
+
+		t.Run("verify created", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for _, id := range []string{
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+					fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+				} {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.True(t, exists)
+				}
+			}
+		})
+	})
+
+	t.Run("fails creating objects of MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Pizza"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaPizzaForTenants(t, client)
+		fixtures.CreateTenantsPizza(t, client, tenants...)
+
+		wrap, err := client.Data().Creator().
+			WithClassName(className).
+			WithID(fixtures.PIZZA_QUATTRO_FORMAGGI_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Quattro Formaggi",
+				"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+				"price":       float32(1.1),
+				"best_before": "2022-05-03T12:04:40+02:00",
+			}).
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+		require.Nil(t, wrap)
+
+		wrap, err = client.Data().Creator().
+			WithClassName(className).
+			WithID(fixtures.PIZZA_FRUTTI_DI_MARE_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Frutti di Mare",
+				"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+				"price":       float32(1.2),
+				"best_before": "2022-05-05T07:16:30+02:00",
+			}).
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+		require.Nil(t, wrap)
+
+		t.Run("verify not created", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for _, id := range []string{
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+					fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+				} {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.False(t, exists)
+				}
+			}
+		})
+	})
+
+	t.Run("fails creating objects of MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Pizza"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaPizzaForTenants(t, client)
+		fixtures.CreateTenantsPizza(t, client, tenants...)
+
+		wrap, err := client.Data().Creator().
+			WithClassName(className).
+			WithID(fixtures.PIZZA_QUATTRO_FORMAGGI_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Quattro Formaggi",
+				"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+				"price":       float32(1.1),
+				"best_before": "2022-05-03T12:04:40+02:00",
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "tenant not found")
+		require.Nil(t, wrap)
+
+		wrap, err = client.Data().Creator().
+			WithClassName(className).
+			WithID(fixtures.PIZZA_FRUTTI_DI_MARE_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Frutti di Mare",
+				"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+				"price":       float32(1.2),
+				"best_before": "2022-05-05T07:16:30+02:00",
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "tenant not found")
+		require.Nil(t, wrap)
+
+		t.Run("verify not created", func(t *testing.T) {
+			for _, tenant := range tenants {
+				for _, id := range []string{
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+					fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+				} {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.False(t, exists)
+				}
+			}
+		})
+	})
+
+	t.Run("fails creating objects of non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Pizza"
+
+		fixtures.CreateSchemaPizza(t, client)
+
+		wrap, err := client.Data().Creator().
+			WithClassName(className).
+			WithID(fixtures.PIZZA_QUATTRO_FORMAGGI_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Quattro Formaggi",
+				"description": "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.",
+				"price":       float32(1.1),
+				"best_before": "2022-05-03T12:04:40+02:00",
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+		require.Nil(t, wrap)
+
+		wrap, err = client.Data().Creator().
+			WithClassName(className).
+			WithID(fixtures.PIZZA_FRUTTI_DI_MARE_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Frutti di Mare",
+				"description": "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.",
+				"price":       float32(1.2),
+				"best_before": "2022-05-05T07:16:30+02:00",
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+		require.Nil(t, wrap)
+
+		t.Run("verify not created", func(t *testing.T) {
+			objects, err := client.Data().ObjectsGetter().
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			assert.Len(t, objects, 0)
+		})
+	})
+
+	t.Run("gets objects of MT class", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		extractIds := func(objs []*models.Object) []string {
+			ids := make([]string, len(objs))
+			for i, obj := range objs {
+				ids[i] = obj.ID.String()
+			}
+			return ids
+		}
+
+		for _, tenant := range tenants {
+			for className, ids := range fixtures.IdsByClass {
+				for _, id := range ids {
+					t.Run("single object by class+id", func(t *testing.T) {
+						objects, err := client.Data().ObjectsGetter().
+							WithID(id).
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						require.Len(t, objects, 1)
+						assert.Equal(t, strfmt.UUID(id), objects[0].ID)
+						assert.Equal(t, tenant.Name, objects[0].Tenant)
+					})
+				}
+
+				t.Run("list objects by class", func(t *testing.T) {
+					objects, err := client.Data().ObjectsGetter().
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.NotNil(t, objects)
+					require.Len(t, objects, len(ids))
+					assert.ElementsMatch(t, ids, extractIds(objects))
+				})
+			}
+
+			t.Run("list all objects", func(t *testing.T) {
+				objects, err := client.Data().ObjectsGetter().
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, len(fixtures.AllIds))
+				assert.ElementsMatch(t, fixtures.AllIds, extractIds(objects))
+			})
+		}
+	})
+
+	t.Run("fails getting objects of MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				t.Run("single object by class+id", func(t *testing.T) {
+					objects, err := client.Data().ObjectsGetter().
+						WithID(id).
+						WithClassName(className).
+						Do(context.Background())
+
+					require.NotNil(t, err)
+					clientErr := err.(*fault.WeaviateClientError)
+					assert.Equal(t, 422, clientErr.StatusCode)
+					assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+					assert.Nil(t, objects)
+				})
+			}
+
+			t.Run("list objects by class", func(t *testing.T) {
+				objects, err := client.Data().ObjectsGetter().
+					WithClassName(className).
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+				assert.Nil(t, objects)
+			})
+		}
+
+		t.Run("list all objects", func(t *testing.T) {
+			objects, err := client.Data().ObjectsGetter().
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			assert.Len(t, objects, 0)
+		})
+	})
+
+	t.Run("fails getting objects of MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				t.Run("single object by class+id", func(t *testing.T) {
+					objects, err := client.Data().ObjectsGetter().
+						WithID(id).
+						WithClassName(className).
+						WithTenant("nonExistentTenant").
+						Do(context.Background())
+
+					require.NotNil(t, err)
+					clientErr := err.(*fault.WeaviateClientError)
+					assert.Equal(t, 422, clientErr.StatusCode)
+					assert.Contains(t, clientErr.Msg, "tenant not found")
+					assert.Nil(t, objects)
+				})
+			}
+
+			t.Run("list objects by class", func(t *testing.T) {
+				objects, err := client.Data().ObjectsGetter().
+					WithClassName(className).
+					WithTenant("nonExistentTenant").
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Contains(t, clientErr.Msg, "tenant not found")
+				assert.Nil(t, objects)
+			})
+		}
+
+		t.Run("list all objects", func(t *testing.T) {
+			objects, err := client.Data().ObjectsGetter().
+				WithTenant("nonExistentTenant").
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			assert.Len(t, objects, 0)
+		})
+	})
+
+	t.Run("fails getting objects of non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		fixtures.CreateSchemaFood(t, client)
+		fixtures.CreateDataFood(t, client)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				t.Run("single object by class+id", func(t *testing.T) {
+					objects, err := client.Data().ObjectsGetter().
+						WithID(id).
+						WithClassName(className).
+						WithTenant("nonExistentTenant").
+						Do(context.Background())
+
+					require.NotNil(t, err)
+					clientErr := err.(*fault.WeaviateClientError)
+					assert.Equal(t, 422, clientErr.StatusCode)
+					assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+					require.Nil(t, objects)
+				})
+			}
+
+			t.Run("list objects by class", func(t *testing.T) {
+				objects, err := client.Data().ObjectsGetter().
+					WithClassName(className).
+					WithTenant("nonExistentTenant").
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+				require.Nil(t, objects)
+			})
+		}
+
+		t.Run("list all objects", func(t *testing.T) {
+			objects, err := client.Data().ObjectsGetter().
+				WithTenant("nonExistentTenant").
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			assert.Len(t, objects, 0)
+		})
+	})
+
+	t.Run("checks objects of MT class", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for _, tenant := range tenants {
+			for className, ids := range fixtures.IdsByClass {
+				for _, id := range ids {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.True(t, exists)
+				}
+			}
+		}
+	})
+
+	t.Run("fails checking objects of MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				exists, err := client.Data().Checker().
+					WithID(id).
+					WithClassName(className).
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Empty(t, clientErr.Msg) // no body in HEAD
+				assert.False(t, exists)
+			}
+		}
+	})
+
+	t.Run("fails checking objects of MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				exists, err := client.Data().Checker().
+					WithID(id).
+					WithClassName(className).
+					WithTenant("nonExistentTenant").
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Empty(t, clientErr.Msg) // no body in HEAD
+				assert.False(t, exists)
+			}
+		}
+	})
+
+	t.Run("fails checking objects of non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		fixtures.CreateSchemaFood(t, client)
+		fixtures.CreateDataFood(t, client)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				exists, err := client.Data().Checker().
+					WithID(id).
+					WithClassName(className).
+					WithTenant("nonExistentTenant").
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Empty(t, clientErr.Msg) // no body in HEAD
+				require.False(t, exists)
+			}
+		}
+	})
+
+	t.Run("deletes objects from MT class", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for _, tenant := range tenants {
+			for className, ids := range fixtures.IdsByClass {
+				expectedLeft := len(ids)
+
+				for _, id := range ids {
+					err := client.Data().Deleter().
+						WithID(id).
+						WithClassName(className).
+						WithTenant(tenant.Name).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					expectedLeft--
+
+					t.Run("verify deleted", func(t *testing.T) {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.False(t, exists)
+					})
+
+					t.Run("verify left", func(t *testing.T) {
+						objects, err := client.Data().ObjectsGetter().
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.NotNil(t, objects)
+						assert.Len(t, objects, expectedLeft)
+					})
+				}
+			}
+		}
+	})
+
+	t.Run("fails deleting objects from MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				err := client.Data().Deleter().
+					WithID(id).
+					WithClassName(className).
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+
+				t.Run("verify not deleted", func(t *testing.T) {
+					for _, tenant := range tenants {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.True(t, exists)
+					}
+				})
+			}
+		}
+
+		t.Run("verify not deleted", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				assert.Len(t, objects, len(fixtures.AllIds))
+			}
+		})
+	})
+
+	t.Run("fails deleting objects from MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaFoodForTenants(t, client)
+		fixtures.CreateTenantsFood(t, client, tenants...)
+		fixtures.CreateDataFoodForTenants(t, client, tenants.Names()...)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				err := client.Data().Deleter().
+					WithID(id).
+					WithClassName(className).
+					WithTenant("nonExistentTenant").
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Contains(t, clientErr.Msg, "tenant not found")
+
+				t.Run("verify not deleted", func(t *testing.T) {
+					for _, tenant := range tenants {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(className).
+							WithTenant(tenant.Name).
+							Do(context.Background())
+
+						require.Nil(t, err)
+						require.True(t, exists)
+					}
+				})
+			}
+		}
+
+		t.Run("verify not deleted", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				assert.Len(t, objects, len(fixtures.AllIds))
+			}
+		})
+	})
+
+	t.Run("fails deleting objects from non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		fixtures.CreateSchemaFood(t, client)
+		fixtures.CreateDataFood(t, client)
+
+		for className, ids := range fixtures.IdsByClass {
+			for _, id := range ids {
+				err := client.Data().Deleter().
+					WithID(id).
+					WithClassName(className).
+					WithTenant("nonExistentTenant").
+					Do(context.Background())
+
+				require.NotNil(t, err)
+				clientErr := err.(*fault.WeaviateClientError)
+				assert.Equal(t, 422, clientErr.StatusCode)
+				assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+
+				t.Run("verify not deleted", func(t *testing.T) {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						Do(context.Background())
+
+					require.Nil(t, err)
+					require.True(t, exists)
+				})
+			}
+		}
+
+		t.Run("verify not deleted", func(t *testing.T) {
+			objects, err := client.Data().ObjectsGetter().
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			assert.Len(t, objects, len(fixtures.AllIds))
+		})
+	})
+
+	t.Run("updates objects of MT class", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+		fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+		for _, tenant := range tenants {
+			err := client.Data().Updater().
+				WithClassName(className).
+				WithID(fixtures.SOUP_CHICKENSOUP_ID).
+				WithProperties(map[string]interface{}{
+					"name":        "ChickenSoup",
+					"description": fmt.Sprintf("updated ChickenSoup description [%s]", tenant),
+					"price":       float32(2.1),
+				}).
+				WithTenant(tenant.Name).
+				Do(context.Background())
+
+			require.Nil(t, err)
+
+			err = client.Data().Updater().
+				WithClassName(className).
+				WithID(fixtures.SOUP_BEAUTIFUL_ID).
+				WithProperties(map[string]interface{}{
+					"name":        "Beautiful",
+					"description": fmt.Sprintf("updated Beautiful description [%s]", tenant),
+					"price":       float32(2.2),
+				}).
+				WithTenant(tenant.Name).
+				Do(context.Background())
+
+			require.Nil(t, err)
+		}
+
+		t.Run("verify updated", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_CHICKENSOUP_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, fmt.Sprintf("updated ChickenSoup description [%s]", tenant),
+					objects[0].Properties.(map[string]interface{})["description"])
+
+				objects, err = client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_BEAUTIFUL_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, fmt.Sprintf("updated Beautiful description [%s]", tenant),
+					objects[0].Properties.(map[string]interface{})["description"])
+			}
+		})
+	})
+
+	t.Run("fails updating objects of MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+		fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+		err := client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_CHICKENSOUP_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "ChickenSoup",
+				"description": "updated ChickenSoup description",
+				"price":       float32(2.1),
+			}).
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+
+		err = client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_BEAUTIFUL_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Beautiful",
+				"description": "updated Beautiful description",
+				"price":       float32(2.2),
+			}).
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+
+		t.Run("verify not updated", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_CHICKENSOUP_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+					objects[0].Properties.(map[string]interface{})["description"])
+
+				objects, err = client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_BEAUTIFUL_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Putting the game of letter soups to a whole new level.",
+					objects[0].Properties.(map[string]interface{})["description"])
+			}
+		})
+	})
+
+	t.Run("fails updating objects of MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+		fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+		err := client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_CHICKENSOUP_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "ChickenSoup",
+				"description": "updated ChickenSoup description",
+				"price":       float32(2.1),
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "tenant not found")
+
+		err = client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_BEAUTIFUL_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Beautiful",
+				"description": "updated Beautiful description",
+				"price":       float32(2.2),
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "tenant not found")
+
+		t.Run("verify not updated", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_CHICKENSOUP_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+					objects[0].Properties.(map[string]interface{})["description"])
+
+				objects, err = client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_BEAUTIFUL_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Putting the game of letter soups to a whole new level.",
+					objects[0].Properties.(map[string]interface{})["description"])
+			}
+		})
+	})
+
+	t.Run("fails updating objects of non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+
+		fixtures.CreateSchemaSoup(t, client)
+		fixtures.CreateDataSoup(t, client)
+
+		err := client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_CHICKENSOUP_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "ChickenSoup",
+				"description": "updated ChickenSoup description",
+				"price":       float32(2.1),
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+
+		err = client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_BEAUTIFUL_ID).
+			WithProperties(map[string]interface{}{
+				"name":        "Beautiful",
+				"description": "updated Beautiful description",
+				"price":       float32(2.2),
+			}).
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+
+		t.Run("verify not updated", func(t *testing.T) {
+			objects, err := client.Data().ObjectsGetter().
+				WithID(fixtures.SOUP_CHICKENSOUP_ID).
+				WithClassName(className).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			require.Len(t, objects, 1)
+			assert.Equal(t, "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+				objects[0].Properties.(map[string]interface{})["description"])
+
+			objects, err = client.Data().ObjectsGetter().
+				WithID(fixtures.SOUP_BEAUTIFUL_ID).
+				WithClassName(className).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			require.Len(t, objects, 1)
+			assert.Equal(t, "Putting the game of letter soups to a whole new level.",
+				objects[0].Properties.(map[string]interface{})["description"])
+		})
+	})
+
+	t.Run("merges objects of MT class", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+		fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+		for _, tenant := range tenants {
+			err := client.Data().Updater().
+				WithClassName(className).
+				WithID(fixtures.SOUP_CHICKENSOUP_ID).
+				WithProperties(map[string]interface{}{
+					"description": fmt.Sprintf("merged ChickenSoup description [%s]", tenant),
+				}).
+				WithTenant(tenant.Name).
+				WithMerge().
+				Do(context.Background())
+
+			require.Nil(t, err)
+
+			err = client.Data().Updater().
+				WithClassName(className).
+				WithID(fixtures.SOUP_BEAUTIFUL_ID).
+				WithProperties(map[string]interface{}{
+					"description": fmt.Sprintf("merged Beautiful description [%s]", tenant),
+				}).
+				WithTenant(tenant.Name).
+				WithMerge().
+				Do(context.Background())
+
+			require.Nil(t, err)
+		}
+
+		t.Run("verify merged", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_CHICKENSOUP_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, fmt.Sprintf("merged ChickenSoup description [%s]", tenant),
+					objects[0].Properties.(map[string]interface{})["description"])
+
+				objects, err = client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_BEAUTIFUL_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, fmt.Sprintf("merged Beautiful description [%s]", tenant),
+					objects[0].Properties.(map[string]interface{})["description"])
+			}
+		})
+	})
+
+	t.Run("fails merging objects of MT class without tenant", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+		fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+		err := client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_CHICKENSOUP_ID).
+			WithProperties(map[string]interface{}{
+				"description": "merged ChickenSoup description",
+			}).
+			WithMerge().
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+
+		err = client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_BEAUTIFUL_ID).
+			WithProperties(map[string]interface{}{
+				"description": "merged Beautiful description",
+			}).
+			WithMerge().
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy enabled, but request was without tenant")
+
+		t.Run("verify not merged", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_CHICKENSOUP_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+					objects[0].Properties.(map[string]interface{})["description"])
+
+				objects, err = client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_BEAUTIFUL_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Putting the game of letter soups to a whole new level.",
+					objects[0].Properties.(map[string]interface{})["description"])
+			}
+		})
+	})
+
+	t.Run("fails merging objects of MT class with non existent tenant", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+		tenants := fixtures.Tenants{
+			{Name: "tenantNo1"},
+			{Name: "tenantNo2"},
+		}
+
+		fixtures.CreateSchemaSoupForTenants(t, client)
+		fixtures.CreateTenantsSoup(t, client, tenants...)
+		fixtures.CreateDataSoupForTenants(t, client, tenants.Names()...)
+
+		err := client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_CHICKENSOUP_ID).
+			WithProperties(map[string]interface{}{
+				"description": "merged ChickenSoup description",
+			}).
+			WithMerge().
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "tenant not found")
+
+		err = client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_BEAUTIFUL_ID).
+			WithProperties(map[string]interface{}{
+				"description": "merged Beautiful description",
+			}).
+			WithMerge().
+			WithTenant("nonExistentTenant").
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "tenant not found")
+
+		t.Run("verify not merged", func(t *testing.T) {
+			for _, tenant := range tenants {
+				objects, err := client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_CHICKENSOUP_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+					objects[0].Properties.(map[string]interface{})["description"])
+
+				objects, err = client.Data().ObjectsGetter().
+					WithID(fixtures.SOUP_BEAUTIFUL_ID).
+					WithClassName(className).
+					WithTenant(tenant.Name).
+					Do(context.Background())
+
+				require.Nil(t, err)
+				require.NotNil(t, objects)
+				require.Len(t, objects, 1)
+				assert.Equal(t, tenant.Name, objects[0].Tenant)
+				assert.Equal(t, "Putting the game of letter soups to a whole new level.",
+					objects[0].Properties.(map[string]interface{})["description"])
+			}
+		})
+	})
+
+	t.Run("fails merging objects of non-MT class when tenant given", func(t *testing.T) {
+		defer cleanup()
+
+		className := "Soup"
+
+		fixtures.CreateSchemaSoup(t, client)
+		fixtures.CreateDataSoup(t, client)
+
+		err := client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_CHICKENSOUP_ID).
+			WithProperties(map[string]interface{}{
+				"description": "merged ChickenSoup description [%s]",
+			}).
+			WithTenant("nonExistentTenant").
+			WithMerge().
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr := err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+
+		err = client.Data().Updater().
+			WithClassName(className).
+			WithID(fixtures.SOUP_BEAUTIFUL_ID).
+			WithProperties(map[string]interface{}{
+				"description": "merged Beautiful description [%s]",
+			}).
+			WithTenant("nonExistentTenant").
+			WithMerge().
+			Do(context.Background())
+
+		require.NotNil(t, err)
+		clientErr = err.(*fault.WeaviateClientError)
+		assert.Equal(t, 422, clientErr.StatusCode)
+		assert.Contains(t, clientErr.Msg, "has multi-tenancy disabled, but request was with tenant")
+
+		t.Run("verify not merged", func(t *testing.T) {
+			objects, err := client.Data().ObjectsGetter().
+				WithID(fixtures.SOUP_CHICKENSOUP_ID).
+				WithClassName(className).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			require.Len(t, objects, 1)
+			assert.Equal(t, "Used by humans when their inferior genetics are attacked by microscopic organisms.",
+				objects[0].Properties.(map[string]interface{})["description"])
+
+			objects, err = client.Data().ObjectsGetter().
+				WithID(fixtures.SOUP_BEAUTIFUL_ID).
+				WithClassName(className).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, objects)
+			require.Len(t, objects, 1)
+			assert.Equal(t, "Putting the game of letter soups to a whole new level.",
+				objects[0].Properties.(map[string]interface{})["description"])
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/multi_tenancy_tests/graphql_test.go

@@ -0,0 +1,514 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package multi_tenancy_tests
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/entities/schema"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "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"
+)
+
+func TestGraphQL_MultiTenancy(t *testing.T) {
+	client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+	require.Nil(t, err)
+
+	cleanup := func() {
+		err := client.Schema().AllDeleter().Do(context.Background())
+		require.Nil(t, err)
+	}
+
+	t.Run("GraphQL Get", func(t *testing.T) {
+		defer cleanup()
+
+		tenant1 := models.Tenant{Name: "tenantNo1"}
+		tenant2 := models.Tenant{Name: "tenantNo2"}
+
+		assertGetContainsIds := func(t *testing.T, response *models.GraphQLResponse,
+			className string, expectedIds []string,
+		) {
+			require.NotNil(t, response)
+			assert.Nil(t, response.Errors)
+			require.NotNil(t, response.Data)
+
+			get := response.Data["Get"].(map[string]interface{})
+			objects := get[className].([]interface{})
+			require.Len(t, objects, len(expectedIds))
+
+			ids := []string{}
+			for i := range objects {
+				ids = append(ids, objects[i].(map[string]interface{})["_additional"].(map[string]interface{})["id"].(string))
+			}
+			assert.ElementsMatch(t, expectedIds, ids)
+		}
+
+		t.Run("add data", func(t *testing.T) {
+			fixtures.CreateSchemaPizzaForTenants(t, client)
+			fixtures.CreateTenantsPizza(t, client, tenant1, tenant2)
+			fixtures.CreateDataPizzaQuattroFormaggiForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaFruttiDiMareForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaHawaiiForTenants(t, client, tenant2.Name)
+			fixtures.CreateDataPizzaDoenerForTenants(t, client, tenant2.Name)
+		})
+
+		t.Run("get all data for tenant", func(t *testing.T) {
+			expectedIdsByTenant := map[string][]string{
+				tenant1.Name: {
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+					fixtures.PIZZA_FRUTTI_DI_MARE_ID,
+				},
+				tenant2.Name: {
+					fixtures.PIZZA_HAWAII_ID,
+					fixtures.PIZZA_DOENER_ID,
+				},
+			}
+
+			for tenant, expectedIds := range expectedIdsByTenant {
+				resp, err := client.GraphQL().Get().
+					WithClassName("Pizza").
+					WithTenant(tenant).
+					WithFields(graphql.Field{
+						Name:   "_additional",
+						Fields: []graphql.Field{{Name: "id"}},
+					}).
+					Do(context.Background())
+
+				assert.Nil(t, err)
+				assertGetContainsIds(t, resp, "Pizza", expectedIds)
+			}
+		})
+
+		t.Run("get limited data for tenant", func(t *testing.T) {
+			expectedIdsByTenant := map[string][]string{
+				tenant1.Name: {
+					fixtures.PIZZA_QUATTRO_FORMAGGI_ID,
+				},
+				tenant2.Name: {
+					fixtures.PIZZA_HAWAII_ID,
+				},
+			}
+
+			for tenant, expectedIds := range expectedIdsByTenant {
+				resp, err := client.GraphQL().Get().
+					WithClassName("Pizza").
+					WithTenant(tenant).
+					WithLimit(1).
+					WithFields(graphql.Field{
+						Name:   "_additional",
+						Fields: []graphql.Field{{Name: "id"}},
+					}).
+					Do(context.Background())
+
+				assert.Nil(t, err)
+				assertGetContainsIds(t, resp, "Pizza", expectedIds)
+			}
+		})
+
+		t.Run("get filtered data for tenant", func(t *testing.T) {
+			expectedIdsByTenant := map[string][]string{
+				tenant1.Name: {},
+				tenant2.Name: {
+					fixtures.PIZZA_DOENER_ID,
+				},
+			}
+			where := filters.Where().
+				WithPath([]string{"price"}).
+				WithOperator(filters.GreaterThan).
+				WithValueNumber(1.3)
+
+			for tenant, expectedIds := range expectedIdsByTenant {
+				resp, err := client.GraphQL().Get().
+					WithClassName("Pizza").
+					WithTenant(tenant).
+					WithWhere(where).
+					WithFields(graphql.Field{
+						Name:   "_additional",
+						Fields: []graphql.Field{{Name: "id"}},
+					}).
+					Do(context.Background())
+
+				assert.Nil(t, err)
+				assertGetContainsIds(t, resp, "Pizza", expectedIds)
+			}
+		})
+	})
+
+	t.Run("GraphQL Get referenced class", func(t *testing.T) {
+		defer cleanup()
+
+		tenant1 := models.Tenant{Name: "tenantNo1"}
+		tenant2 := models.Tenant{Name: "tenantNo2"}
+		soupIdByTenantAndPizza := map[string]map[string]string{
+			tenant1.Name: {
+				fixtures.PIZZA_QUATTRO_FORMAGGI_ID: fixtures.SOUP_CHICKENSOUP_ID,
+				fixtures.PIZZA_FRUTTI_DI_MARE_ID:   fixtures.SOUP_CHICKENSOUP_ID,
+			},
+			tenant2.Name: {
+				fixtures.PIZZA_HAWAII_ID: fixtures.SOUP_BEAUTIFUL_ID,
+				fixtures.PIZZA_DOENER_ID: fixtures.SOUP_BEAUTIFUL_ID,
+			},
+		}
+
+		assertGetContainsIds := func(t *testing.T, response *models.GraphQLResponse,
+			className string, expectedIds ...string,
+		) {
+			require.NotNil(t, response)
+			assert.Nil(t, response.Errors)
+			require.NotNil(t, response.Data)
+
+			get := response.Data["Get"].(map[string]interface{})
+			objects := get[className].([]interface{})
+			require.Len(t, objects, len(expectedIds))
+
+			ids := []string{}
+			for i := range objects {
+				ids = append(ids, objects[i].(map[string]interface{})["_additional"].(map[string]interface{})["id"].(string))
+			}
+			assert.ElementsMatch(t, expectedIds, ids)
+		}
+
+		t.Run("add data", func(t *testing.T) {
+			fixtures.CreateSchemaPizzaForTenants(t, client)
+			fixtures.CreateTenantsPizza(t, client, tenant1, tenant2)
+			fixtures.CreateDataPizzaQuattroFormaggiForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaFruttiDiMareForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaHawaiiForTenants(t, client, tenant2.Name)
+			fixtures.CreateDataPizzaDoenerForTenants(t, client, tenant2.Name)
+
+			fixtures.CreateSchemaSoupForTenants(t, client)
+			fixtures.CreateTenantsSoup(t, client, tenant1, tenant2)
+			fixtures.CreateDataSoupChickenForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataSoupBeautifulForTenants(t, client, tenant2.Name)
+		})
+
+		t.Run("create ref property", func(t *testing.T) {
+			err := client.Schema().PropertyCreator().
+				WithClassName("Soup").
+				WithProperty(&models.Property{
+					Name:     "relatedToPizza",
+					DataType: []string{"Pizza"},
+				}).
+				Do(context.Background())
+
+			require.Nil(t, err)
+		})
+
+		t.Run("create refs", func(t *testing.T) {
+			references := []*models.BatchReference{}
+
+			for tenant, pizzaToSoup := range soupIdByTenantAndPizza {
+				for pizzaId, soupId := range pizzaToSoup {
+					rpb := client.Batch().ReferencePayloadBuilder().
+						WithFromClassName("Soup").
+						WithFromRefProp("relatedToPizza").
+						WithFromID(soupId).
+						WithToClassName("Pizza").
+						WithToID(pizzaId).
+						WithTenant(tenant)
+
+					references = append(references, rpb.Payload())
+				}
+			}
+
+			resp, err := client.Batch().ReferencesBatcher().
+				WithReferences(references...).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			require.NotNil(t, resp)
+			assert.Len(t, resp, len(references))
+			for i := range resp {
+				require.NotNil(t, resp[i].Result)
+				assert.Nil(t, resp[i].Result.Errors)
+			}
+		})
+
+		for tenant, pizzaToSoup := range soupIdByTenantAndPizza {
+			for pizzaId, expectedSoupId := range pizzaToSoup {
+				resp, err := client.GraphQL().Get().
+					WithClassName("Soup").
+					WithTenant(tenant).
+					WithFields(graphql.Field{
+						Name:   "_additional",
+						Fields: []graphql.Field{{Name: "id"}},
+					}).
+					WithWhere(filters.Where().
+						WithOperator(filters.Equal).
+						WithPath([]string{"relatedToPizza", "Pizza", "_id"}).
+						WithValueText(pizzaId)).
+					Do(context.Background())
+
+				assert.Nil(t, err)
+				assertGetContainsIds(t, resp, "Soup", expectedSoupId)
+			}
+		}
+	})
+
+	t.Run("GraphQL Aggregate", func(t *testing.T) {
+		defer cleanup()
+
+		tenant1 := models.Tenant{Name: "tenantNo1"}
+		tenant2 := models.Tenant{Name: "tenantNo2"}
+
+		assertAggregateNumFieldHasValues := func(t *testing.T, response *models.GraphQLResponse,
+			className string, fieldName string, expectedAggValues map[string]*float64,
+		) {
+			require.NotNil(t, response)
+			assert.Nil(t, response.Errors)
+			require.NotNil(t, response.Data)
+
+			agg := response.Data["Aggregate"].(map[string]interface{})
+			require.NotNil(t, agg)
+
+			objects := agg[className].([]interface{})
+			require.Len(t, objects, 1)
+			obj := objects[0].(map[string]interface{})[fieldName].(map[string]interface{})
+
+			for name, value := range expectedAggValues {
+				if value == nil {
+					assert.Nil(t, obj[name])
+				} else {
+					assert.Equal(t, *value, obj[name])
+				}
+			}
+		}
+		ptr := func(f float64) *float64 {
+			return &f
+		}
+
+		t.Run("add data", func(t *testing.T) {
+			fixtures.CreateSchemaPizzaForTenants(t, client)
+			fixtures.CreateTenantsPizza(t, client, tenant1, tenant2)
+			fixtures.CreateDataPizzaQuattroFormaggiForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaFruttiDiMareForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaHawaiiForTenants(t, client, tenant2.Name)
+			fixtures.CreateDataPizzaDoenerForTenants(t, client, tenant2.Name)
+		})
+
+		t.Run("aggregate all data for tenant", func(t *testing.T) {
+			expectedAggValuesByTenant := map[string]map[string]*float64{
+				tenant1.Name: {
+					"count":   ptr(2),
+					"maximum": ptr(1.2),
+					"minimum": ptr(1.1),
+					"median":  ptr(1.15),
+					"mean":    ptr(1.15),
+					"mode":    ptr(1.1),
+					"sum":     ptr(2.3),
+				},
+				tenant2.Name: {
+					"count":   ptr(2),
+					"maximum": ptr(1.4),
+					"minimum": ptr(1.3),
+					"median":  ptr(1.35),
+					"mean":    ptr(1.35),
+					"mode":    ptr(1.3),
+					"sum":     ptr(2.7),
+				},
+			}
+
+			for tenant, expectedAggValues := range expectedAggValuesByTenant {
+				resp, err := client.GraphQL().Aggregate().
+					WithClassName("Pizza").
+					WithTenant(tenant).
+					WithFields(graphql.Field{
+						Name: "price",
+						Fields: []graphql.Field{
+							{Name: "count"},
+							{Name: "maximum"},
+							{Name: "minimum"},
+							{Name: "median"},
+							{Name: "mean"},
+							{Name: "mode"},
+							{Name: "sum"},
+						},
+					}).
+					Do(context.Background())
+
+				assert.Nil(t, err)
+				assertAggregateNumFieldHasValues(t, resp, "Pizza", "price", expectedAggValues)
+			}
+		})
+
+		t.Run("aggregate filtered data for tenant", func(t *testing.T) {
+			expectedAggValuesByTenant := map[string]map[string]*float64{
+				tenant1.Name: {
+					"count":   ptr(0),
+					"maximum": nil,
+					"minimum": nil,
+					"median":  nil,
+					"mean":    nil,
+					"mode":    nil,
+					"sum":     nil,
+				},
+				tenant2.Name: {
+					"count":   ptr(1),
+					"maximum": ptr(1.4),
+					"minimum": ptr(1.4),
+					"median":  ptr(1.4),
+					"mean":    ptr(1.4),
+					"mode":    ptr(1.4),
+					"sum":     ptr(1.4),
+				},
+			}
+			where := filters.Where().
+				WithPath([]string{"price"}).
+				WithOperator(filters.GreaterThan).
+				WithValueNumber(1.3)
+
+			for tenant, expectedAggValues := range expectedAggValuesByTenant {
+				resp, err := client.GraphQL().Aggregate().
+					WithClassName("Pizza").
+					WithTenant(tenant).
+					WithWhere(where).
+					WithFields(graphql.Field{
+						Name: "price",
+						Fields: []graphql.Field{
+							{Name: "count"},
+							{Name: "maximum"},
+							{Name: "minimum"},
+							{Name: "median"},
+							{Name: "mean"},
+							{Name: "mode"},
+							{Name: "sum"},
+						},
+					}).
+					Do(context.Background())
+
+				assert.Nil(t, err)
+				assertAggregateNumFieldHasValues(t, resp, "Pizza", "price", expectedAggValues)
+			}
+		})
+	})
+
+	t.Run("GraphQL Explore", func(t *testing.T) {
+		defer cleanup()
+
+		tenant1 := models.Tenant{Name: "tenantNo1"}
+		tenant2 := models.Tenant{Name: "tenantNo2"}
+
+		assertExploreContainsErrors := func(t *testing.T, response *models.GraphQLResponse,
+			expectedErrorMessage string,
+		) {
+			require.NotNil(t, response)
+			require.NotNil(t, response.Errors)
+			require.Nil(t, response.Data["Explore"])
+			require.NotNil(t, response.Data)
+			require.Len(t, response.Errors, 1)
+			assert.NotEmpty(t, response.Errors[0].Message)
+			assert.Equal(t, expectedErrorMessage, response.Errors[0].Message)
+		}
+
+		t.Run("add data", func(t *testing.T) {
+			fixtures.CreateSchemaPizzaForTenants(t, client)
+			fixtures.CreateTenantsPizza(t, client, tenant1, tenant2)
+			fixtures.CreateDataPizzaQuattroFormaggiForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaFruttiDiMareForTenants(t, client, tenant1.Name)
+			fixtures.CreateDataPizzaHawaiiForTenants(t, client, tenant2.Name)
+			fixtures.CreateDataPizzaDoenerForTenants(t, client, tenant2.Name)
+		})
+
+		t.Run("explore with nearText", func(t *testing.T) {
+			nearText := client.GraphQL().NearTextArgBuilder().
+				WithConcepts([]string{"Italian"})
+
+			resp, err := client.GraphQL().Explore().
+				WithNearText(nearText).
+				WithFields(graphql.Beacon, graphql.Certainty, graphql.ClassName).
+				Do(context.Background())
+
+			require.Nil(t, err)
+			assertExploreContainsErrors(t, resp,
+				"vector search: search index pizza: class Pizza has multi-tenancy enabled, but request was without tenant",
+			)
+		})
+	})
+}
+
+func TestGroupByMultiTenancy(t *testing.T) {
+	client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: "localhost:8080"})
+	require.Nil(t, err)
+
+	ctx := context.Background()
+
+	defer client.Schema().ClassDeleter().WithClassName("TextContent").Do(ctx)
+	defer client.Schema().ClassDeleter().WithClassName("Document").Do(ctx)
+
+	err = client.Schema().ClassCreator().WithClass(
+		&models.Class{
+			Class:              "TextContent",
+			MultiTenancyConfig: &models.MultiTenancyConfig{Enabled: true},
+			Vectorizer:         "text2vec-contextionary",
+			Properties: []*models.Property{
+				{
+					Name:     "text",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		},
+	).Do(ctx)
+	require.Nil(t, err)
+
+	err = client.Schema().ClassCreator().WithClass(
+		&models.Class{
+			Class:              "Document",
+			MultiTenancyConfig: &models.MultiTenancyConfig{Enabled: true},
+			Vectorizer:         "text2vec-contextionary",
+			Properties: []*models.Property{
+				{
+					Name:     "textContents",
+					DataType: []string{"TextContent"},
+				},
+				{
+					Name:     "title",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		},
+	).Do(ctx)
+	require.Nil(t, err)
+
+	require.Nil(t, client.Schema().PropertyCreator().WithClassName("TextContent").WithProperty(&models.Property{
+		Name:     "contentOf",
+		DataType: []string{"Document"},
+	}).Do(ctx))
+
+	require.Nil(t, client.Schema().TenantsCreator().WithClassName("TextContent").WithTenants(models.Tenant{Name: "1"}).Do(ctx))
+	require.Nil(t, client.Schema().TenantsCreator().WithClassName("Document").WithTenants(models.Tenant{Name: "1"}).Do(ctx))
+
+	docCreator := client.Data().Creator().WithClassName("Document").WithTenant("1")
+	doc1, err := docCreator.WithProperties(map[string]interface{}{"title": "Foo"}).Do(ctx)
+	require.Nil(t, err)
+
+	textCreator := client.Data().Creator().WithClassName("TextContent").WithTenant("1")
+	text1, err := textCreator.WithProperties(map[string]interface{}{"text": "Text from Foo"}).Do(ctx)
+	require.Nil(t, err)
+
+	require.Nil(t, client.Data().ReferenceCreator().WithTenant("1").WithClassName("Document").WithID(doc1.Object.ID.String()).WithReferenceProperty("textContents").WithReference(&models.SingleRef{Beacon: strfmt.URI(fmt.Sprintf("weaviate://localhost/TextContent/%s", text1.Object.ID.String()))}).Do(ctx))
+	require.Nil(t, client.Data().ReferenceCreator().WithTenant("1").WithClassName("TextContent").WithID(text1.Object.ID.String()).WithReferenceProperty("contentOf").WithReference(&models.SingleRef{Beacon: strfmt.URI(fmt.Sprintf("weaviate://localhost/Document/%s", doc1.Object.ID.String()))}).Do(ctx))
+
+	result, err := client.GraphQL().Raw().WithQuery("{Get{TextContent(nearText: {concepts: [\"Foo\"] distance: 1.0} groupBy:{path:[\"contentOf\"], groups:2, objectsPerGroup:1}tenant: \"1\"){contentOf{... on Document{title}}}}}").Do(ctx)
+	require.Nil(t, err)
+	require.NotNil(t, result)
+	require.Nil(t, result.Errors)
+}