Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/test/acceptance/replication/async_replication/async_repair_updates_test.go

@@ -0,0 +1,131 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"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"
+)
+
+func (suite *AsyncReplicationTestSuite) TestAsyncRepairObjectUpdateScenario() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	clusterSize := 3
+
+	compose, err := docker.New().
+		WithWeaviateCluster(clusterSize).
+		WithText2VecContextionary().
+		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()
+
+	paragraphClass := articles.ParagraphsClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       int64(clusterSize),
+			AsyncEnabled: true,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.CreateClass(t, paragraphClass)
+	})
+
+	node := 2
+
+	t.Run(fmt.Sprintf("stop node %d", node), func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, node)
+	})
+
+	t.Run("upsert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+
+		// choose one more node to insert the objects into
+		var targetNode int
+		for {
+			targetNode = 1 + rand.Intn(clusterSize)
+			if targetNode != node {
+				break
+			}
+		}
+
+		common.CreateObjectsCL(t, compose.GetWeaviateNode(targetNode).URI(), batch, types.ConsistencyLevelOne)
+	})
+
+	t.Run(fmt.Sprintf("restart node %d", node), func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, node)
+		time.Sleep(5 * time.Second)
+	})
+
+	t.Run("verify that all nodes are running", func(t *testing.T) {
+		require.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, clusterSize)
+			for _, n := range resp.Nodes {
+				require.NotNil(ct, n.Status)
+				require.Equal(ct, "HEALTHY", *n.Status)
+			}
+		}, 15*time.Second, 500*time.Millisecond)
+	})
+
+	t.Run(fmt.Sprintf("assert node %d has all the objects at its latest version", node), func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			count := common.CountObjects(t, compose.GetWeaviateNode(node).URI(), paragraphClass.Class)
+			require.EqualValues(ct, len(paragraphIDs), count)
+
+			for i, id := range paragraphIDs {
+				resp, err := common.GetObjectCL(t, compose.GetWeaviateNode(node).URI(), paragraphClass.Class, id, types.ConsistencyLevelOne)
+				require.NoError(ct, err)
+				require.NotNil(ct, resp)
+				require.Equal(ct, id, resp.ID)
+
+				props := resp.Properties.(map[string]interface{})
+				props["contents"] = fmt.Sprintf("paragraph#%d", i)
+			}
+		}, 120*time.Second, 5*time.Second, "not all the objects have been asynchronously replicated")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/common/crud_ops.go

@@ -0,0 +1,340 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package common
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/objects"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/filters"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+)
+
+// stopNodeAt stops the node container at the given index.
+//
+// NOTE: the index is 1-based, so stopping the first node requires index=1, not 0
+func StopNodeAt(ctx context.Context, t *testing.T, compose *docker.DockerCompose, index int) {
+	<-time.After(1 * time.Second)
+	if err := compose.StopAt(ctx, index, nil); err != nil {
+		// try one more time after 1 second
+		<-time.After(1 * time.Second)
+		require.NoError(t, compose.StopAt(ctx, index, nil))
+	}
+	<-time.After(1 * time.Second) // give time for shutdown
+}
+
+// startNodeAt starts the node container at the given index.
+//
+// NOTE: the index is 1-based, so starting the first node requires index=1, not 0
+func StartNodeAt(ctx context.Context, t *testing.T, compose *docker.DockerCompose, index int) {
+	t.Helper()
+	if err := compose.StartAt(ctx, index); err != nil {
+		// try one more time after 1 second
+		<-time.After(1 * time.Second)
+		require.NoError(t, compose.StartAt(ctx, index))
+	}
+	<-time.After(1 * time.Second)
+}
+
+func GetClass(t *testing.T, host, class string) *models.Class {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.GetClass(t, class)
+}
+
+func UpdateClass(t *testing.T, host string, class *models.Class) {
+	t.Helper()
+	helper.SetupClient(host)
+	helper.UpdateClass(t, class)
+}
+
+func CreateObjectCL(t *testing.T, host string, obj *models.Object, cl types.ConsistencyLevel) error {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.CreateObjectCL(t, obj, cl)
+}
+
+func CreateObjects(t *testing.T, host string, batch []*models.Object) {
+	t.Helper()
+	helper.SetupClient(host)
+	helper.CreateObjectsBatch(t, batch)
+}
+
+func CreateObjectsCL(t *testing.T, host string, batch []*models.Object, cl types.ConsistencyLevel) {
+	helper.SetupClient(host)
+	helper.CreateObjectsBatchCL(t, batch, cl)
+}
+
+func CreateTenantObjects(t *testing.T, host string, batch []*models.Object) {
+	t.Helper()
+	helper.SetupClient(host)
+	helper.CreateObjectsBatch(t, batch)
+}
+
+func GetObject(t *testing.T, host, class string, id strfmt.UUID, withVec bool) (*models.Object, error) {
+	t.Helper()
+	helper.SetupClient(host)
+	var include string
+	if withVec {
+		include = "vector"
+	}
+	return helper.GetObject(t, class, id, include)
+}
+
+func GetTenantObject(t *testing.T, host, class string, id strfmt.UUID, tenant string) (*models.Object, error) {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.TenantObject(t, class, id, tenant)
+}
+
+func ObjectExistsCL(t *testing.T, host, class string, id strfmt.UUID, cl types.ConsistencyLevel) (bool, error) {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.ObjectExistsCL(t, class, id, cl)
+}
+
+func GetObjectCL(t *testing.T, host, class string, id strfmt.UUID, cl types.ConsistencyLevel) (*models.Object, error) {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.GetObjectCL(t, class, id, cl)
+}
+
+func GetObjectFromNode(t *testing.T, host, class string, id strfmt.UUID, nodename string) (*models.Object, error) {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.GetObjectFromNode(t, class, id, nodename)
+}
+
+func GetTenantObjectFromNode(t *testing.T, host, class string, id strfmt.UUID, nodename, tenant string) (*models.Object, error) {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.GetTenantObjectFromNode(t, class, id, nodename, tenant)
+}
+
+func PatchObject(t *testing.T, host string, patch *models.Object) {
+	t.Helper()
+	helper.SetupClient(host)
+	helper.PatchObject(t, patch)
+}
+
+func UpdateObjectCL(t *testing.T, host string, obj *models.Object, cl types.ConsistencyLevel) error {
+	t.Helper()
+	helper.SetupClient(host)
+	return helper.UpdateObjectCL(t, obj, cl)
+}
+
+func AddReferences(t *testing.T, host string, refs []*models.BatchReference) {
+	t.Helper()
+	helper.SetupClient(host)
+	resp, err := helper.AddReferences(t, refs)
+	helper.CheckReferencesBatchResponse(t, resp, err)
+}
+
+func AddTenantReferences(t *testing.T, host string, refs []*models.BatchReference) {
+	t.Helper()
+	helper.SetupClient(host)
+	resp, err := helper.AddReferences(t, refs)
+	helper.CheckReferencesBatchResponse(t, resp, err)
+}
+
+func DeleteObject(t *testing.T, host, class string, id strfmt.UUID, cl types.ConsistencyLevel) {
+	t.Helper()
+	helper.SetupClient(host)
+
+	_, err := helper.GetObject(t, class, id)
+	require.Nil(t, err)
+
+	helper.DeleteObjectCL(t, class, id, cl)
+
+	_, err = helper.GetObject(t, class, id)
+	require.Equal(t, &objects.ObjectsClassGetNotFound{}, err)
+}
+
+func DeleteTenantObject(t *testing.T, host, class string, id strfmt.UUID, tenant string, cl types.ConsistencyLevel) {
+	helper.SetupClient(host)
+	helper.DeleteTenantObject(t, class, id, tenant, cl)
+
+	_, err := helper.TenantObject(t, class, id, tenant)
+	assert.Equal(t, &objects.ObjectsClassGetNotFound{}, err)
+}
+
+func DeleteObjects(t *testing.T, host, class string, path []string, valueText string, cl types.ConsistencyLevel) {
+	t.Helper()
+	helper.SetupClient(host)
+
+	batchDelete := &models.BatchDelete{
+		Match: &models.BatchDeleteMatch{
+			Class: class,
+			Where: &models.WhereFilter{
+				Operator:  filters.OperatorLike.Name(),
+				Path:      path,
+				ValueText: &valueText,
+			},
+		},
+	}
+	helper.DeleteObjectsBatch(t, batchDelete, cl)
+
+	resp := GQLGet(t, host, class, types.ConsistencyLevelAll)
+	assert.Empty(t, resp)
+}
+
+func DeleteTenantObjects(t *testing.T, host, class string, path []string, valueText, tenant string, cl types.ConsistencyLevel) {
+	t.Helper()
+	helper.SetupClient(host)
+
+	batchDelete := &models.BatchDelete{
+		Match: &models.BatchDeleteMatch{
+			Class: class,
+			Where: &models.WhereFilter{
+				Operator:  filters.OperatorLike.Name(),
+				Path:      path,
+				ValueText: &valueText,
+			},
+		},
+	}
+	resp, err := helper.DeleteTenantObjectsBatchCL(t, batchDelete, tenant, cl)
+	helper.AssertRequestOk(t, resp, err, nil)
+
+	deleted := GQLTenantGet(t, host, class, types.ConsistencyLevelAll, tenant)
+	assert.Empty(t, deleted)
+}
+
+func GQLGet(t *testing.T, host, class string, cl types.ConsistencyLevel, fields ...string) []interface{} {
+	t.Helper()
+	helper.SetupClient(host)
+
+	if cl == "" {
+		cl = types.ConsistencyLevelQuorum
+	}
+
+	q := fmt.Sprintf("{Get {%s (consistencyLevel: %s)", class, cl) + " {%s}}}"
+	if len(fields) == 0 {
+		fields = []string{"_additional{id isConsistent vector}"}
+	}
+	q = fmt.Sprintf(q, strings.Join(fields, " "))
+
+	return GQLDo(t, class, q)
+}
+
+func GQLGetNearVec(t *testing.T, host, class string, vec []interface{}, cl types.ConsistencyLevel, fields ...string) []interface{} {
+	t.Helper()
+	helper.SetupClient(host)
+
+	if cl == "" {
+		cl = types.ConsistencyLevelQuorum
+	}
+
+	q := fmt.Sprintf("{Get {%s (consistencyLevel: %s, nearVector: {vector: %s, certainty: 0.8})",
+		class, cl, Vec2String(vec)) + " {%s}}}"
+	if len(fields) == 0 {
+		fields = []string{"_additional{id isConsistent}"}
+	}
+	q = fmt.Sprintf(q, strings.Join(fields, " "))
+
+	return GQLDo(t, class, q)
+}
+
+func GQLDo(t *testing.T, class, query string) []interface{} {
+	t.Helper()
+	resp := graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+
+	result := resp.Get("Get").Get(class)
+	return result.Result.([]interface{})
+}
+
+func GQLTenantGet(t *testing.T, host, class string, cl types.ConsistencyLevel,
+	tenant string, fields ...string,
+) []interface{} {
+	t.Helper()
+	helper.SetupClient(host)
+
+	if cl == "" {
+		cl = types.ConsistencyLevelQuorum
+	}
+
+	q := fmt.Sprintf("{Get {%s (tenant: %q, consistencyLevel: %s, limit: 1000)", class, tenant, cl) + " {%s}}}"
+	if len(fields) == 0 {
+		fields = []string{"_additional{id isConsistent}"}
+	}
+	q = fmt.Sprintf(q, strings.Join(fields, " "))
+
+	resp := graphqlhelper.AssertGraphQL(t, helper.RootAuth, q)
+
+	result := resp.Get("Get").Get(class)
+	return result.Result.([]interface{})
+}
+
+func CountObjects(t *testing.T, host, class string) int64 {
+	helper.SetupClient(host)
+
+	q := fmt.Sprintf(`{Aggregate{%s{meta{count}}}}`, class)
+
+	resp := graphqlhelper.AssertGraphQL(t, helper.RootAuth, q)
+
+	result := resp.Get("Aggregate").Get(class).AsSlice()
+	require.Len(t, result, 1)
+	meta := result[0].(map[string]interface{})["meta"].(map[string]interface{})
+	count, err := meta["count"].(json.Number).Int64()
+	require.Nil(t, err)
+	return count
+}
+
+func CountTenantObjects(t *testing.T, host, class string,
+	tenant string,
+) int64 {
+	t.Helper()
+	helper.SetupClient(host)
+
+	q := fmt.Sprintf(`{Aggregate{%s(tenant: %q){meta{count}}}}`, class, tenant)
+
+	resp := graphqlhelper.AssertGraphQL(t, helper.RootAuth, q)
+
+	result := resp.Get("Aggregate").Get(class).AsSlice()
+	require.Len(t, result, 1)
+	meta := result[0].(map[string]interface{})["meta"].(map[string]interface{})
+	count, err := meta["count"].(json.Number).Int64()
+	require.Nil(t, err)
+	return count
+}
+
+func GetNodes(t *testing.T, host string) *models.NodesStatusResponse {
+	t.Helper()
+	helper.SetupClient(host)
+	verbose := verbosity.OutputVerbose
+	params := nodes.NewNodesGetParams().WithOutput(&verbose)
+	resp, err := helper.Client(t).Nodes.NodesGet(params, nil)
+	helper.AssertRequestOk(t, resp, err, nil)
+	return resp.Payload
+}
+
+func Vec2String(v []interface{}) (s string) {
+	for _, n := range v {
+		x := n.(json.Number)
+		s = fmt.Sprintf("%s, %s", s, x.String())
+	}
+	s = strings.TrimLeft(s, ", ")
+	return fmt.Sprintf("[%s]", s)
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/read_repair/crud_test.go

@@ -0,0 +1,309 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/weaviate/weaviate/client/objects"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema/crossref"
+	"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"
+)
+
+var (
+	paragraphIDs = []strfmt.UUID{
+		strfmt.UUID("3bf331ac-8c86-4f95-b127-2f8f96bbc093"),
+		strfmt.UUID("47b26ba1-6bc9-41f8-a655-8b9a5b60e1a3"),
+		strfmt.UUID("5fef6289-28d2-4ea2-82a9-48eb501200cd"),
+		strfmt.UUID("34a673b4-8859-4cb4-bb30-27f5622b47e9"),
+		strfmt.UUID("9fa362f5-c2dc-4fb8-b5b2-11701adc5f75"),
+		strfmt.UUID("63735238-6723-4caf-9eaa-113120968ff4"),
+		strfmt.UUID("2236744d-b2d2-40e5-95d8-2574f20a7126"),
+		strfmt.UUID("1a54e25d-aaf9-48d2-bc3c-bef00b556297"),
+		strfmt.UUID("0b8a0e70-a240-44b2-ac6d-26dda97523b9"),
+		strfmt.UUID("50566856-5d0a-4fb1-a390-e099bc236f66"),
+	}
+
+	articleIDs = []strfmt.UUID{
+		strfmt.UUID("aeaf8743-5a8f-4149-b960-444181d3131a"),
+		strfmt.UUID("2a1e9834-064e-4ca8-9efc-35707c6bae6d"),
+		strfmt.UUID("8d101c0c-4deb-48d0-805c-d9c691042a1a"),
+		strfmt.UUID("b9715fec-ef6c-4e8d-a89e-55e2eebee3f6"),
+		strfmt.UUID("faf520f2-f6c3-4cdf-9c16-0348ffd0f8ac"),
+		strfmt.UUID("d4c695dd-4dc7-4e49-bc73-089ef5f90fc8"),
+		strfmt.UUID("c7949324-e07f-4ffc-8be0-194f0470d375"),
+		strfmt.UUID("9c112e01-7759-43ed-a6e8-5defb267c8ee"),
+		strfmt.UUID("9bf847f3-3a1a-45a5-b656-311163e536b5"),
+		strfmt.UUID("c1975388-d67c-404a-ae77-5983fbaea4bb"),
+	}
+)
+
+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) TestImmediateReplicaCRUD() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		With3NodeCluster().
+		WithText2VecContextionary().
+		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.ContainerURI(1))
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	t.Run("CreateSchema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 3,
+		}
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 3,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	t.Run("InsertParagraphsBatch", func(t *testing.T) {
+		t.Run("CreateObjectsOnNode-3", func(t *testing.T) {
+			batch := make([]*models.Object, len(paragraphIDs))
+			for i, id := range paragraphIDs {
+				batch[i] = articles.NewParagraph().
+					WithID(id).
+					WithContents(fmt.Sprintf("paragraph#%d", i)).
+					Object()
+			}
+			common.CreateObjects(t, compose.ContainerURI(3), batch)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("ObjectsExistOnNode-1", func(t *testing.T) {
+			resp := common.GQLGet(t, compose.ContainerURI(1), "Paragraph", types.ConsistencyLevelOne)
+			assert.Len(t, resp, len(paragraphIDs))
+		})
+
+		t.Run("ObjectsExistOnNode-2", func(t *testing.T) {
+			resp := common.GQLGet(t, compose.ContainerURI(2), "Paragraph", types.ConsistencyLevelOne)
+			require.Len(t, resp, len(paragraphIDs))
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			err = compose.StartAt(ctx, 3)
+			require.Nil(t, err)
+		})
+	})
+
+	t.Run("InsertArticlesIndividually", func(t *testing.T) {
+		t.Run("CreateObjectsOnNode 3", func(t *testing.T) {
+			for i, id := range articleIDs {
+				obj := articles.NewArticle().
+					WithID(id).
+					WithTitle(fmt.Sprintf("Article#%d", i)).
+					Object()
+				common.CreateObjectCL(t, compose.ContainerURI(3), obj, types.ConsistencyLevelOne)
+			}
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("ObjectsExistOnNode-1", func(t *testing.T) {
+			resp := common.GQLGet(t, compose.ContainerURI(1), "Article", types.ConsistencyLevelOne)
+			require.Len(t, resp, len(articleIDs))
+		})
+
+		t.Run("ObjectsExistOnNode-2", func(t *testing.T) {
+			resp := common.GQLGet(t, compose.ContainerURI(2), "Article", types.ConsistencyLevelOne)
+			require.Len(t, resp, len(articleIDs))
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			err = compose.StartAt(ctx, 3)
+			require.Nil(t, err)
+		})
+	})
+
+	t.Run("AddReferences", func(t *testing.T) {
+		refs := make([]*models.BatchReference, len(articleIDs))
+		for i := range articleIDs {
+			refs[i] = &models.BatchReference{
+				From: strfmt.URI(crossref.NewSource("Article", "hasParagraphs", articleIDs[i]).String()),
+				To:   strfmt.URI(crossref.NewLocalhost("Paragraph", paragraphIDs[i]).String()),
+			}
+		}
+
+		t.Run("OnNode-3", func(t *testing.T) {
+			common.AddReferences(t, compose.ContainerURI(3), refs)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("ExistOnNode-2", func(t *testing.T) {
+			type additional struct {
+				ID strfmt.UUID `json:"id"`
+			}
+
+			type article struct {
+				Additional    additional `json:"_additional"`
+				HasParagraphs []struct {
+					Additional additional `json:"_additional"`
+				} `json:"hasParagraphs"`
+			}
+
+			// maps article id to referenced paragraph id
+			refPairs := make(map[strfmt.UUID]strfmt.UUID)
+			resp := common.GQLGet(t, compose.ContainerURI(2), "Article", types.ConsistencyLevelOne,
+				"_additional{id}", "hasParagraphs {... on Paragraph {_additional{id}}}")
+			require.Len(t, resp, len(articleIDs))
+
+			for _, r := range resp {
+				b, err := json.Marshal(r)
+				require.Nil(t, err)
+				var art article
+				err = json.Unmarshal(b, &art)
+				require.Nil(t, err)
+				require.Len(t, art.HasParagraphs, 1)
+				refPairs[art.Additional.ID] = art.HasParagraphs[0].Additional.ID
+			}
+
+			for i := range articleIDs {
+				paragraphID, ok := refPairs[articleIDs[i]]
+				require.True(t, ok, "expected %q to be in refPairs: %+v", articleIDs[i], refPairs)
+				require.Equal(t, paragraphIDs[i], paragraphID)
+			}
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			err = compose.StartAt(ctx, 3)
+			require.Nil(t, err)
+		})
+	})
+
+	t.Run("UpdateObject", func(t *testing.T) {
+		before, err := common.GetObject(t, compose.ContainerURI(3), "Article", articleIDs[0], false)
+		require.Nil(t, err)
+		newTitle := "Article#9000"
+
+		t.Run("OnNode-3", func(t *testing.T) {
+			patch := &models.Object{
+				ID:         before.ID,
+				Class:      "Article",
+				Properties: map[string]interface{}{"title": newTitle},
+			}
+			common.UpdateObjectCL(t, compose.ContainerURI(3), patch, types.ConsistencyLevelQuorum)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("PatchedOnNode-1", func(t *testing.T) {
+			after, err := common.GetObjectFromNode(t, compose.ContainerURI(1), "Article", articleIDs[0], "node1")
+			require.Nil(t, err)
+
+			newVal, ok := after.Properties.(map[string]interface{})["title"]
+			require.True(t, ok)
+			require.Equal(t, newTitle, newVal)
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			require.Nil(t, compose.StartAt(ctx, 3))
+		})
+	})
+
+	t.Run("DeleteObject", func(t *testing.T) {
+		t.Run("OnNode-3", func(t *testing.T) {
+			common.DeleteObject(t, compose.ContainerURI(3), "Article", articleIDs[0], types.ConsistencyLevelAll)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("OnNode-1", func(t *testing.T) {
+			_, err := common.GetObjectFromNode(t, compose.ContainerURI(1), "Article", articleIDs[0], "node1")
+			require.Equal(t, &objects.ObjectsClassGetNotFound{}, err)
+		})
+		t.Run("OnNode-2", func(t *testing.T) {
+			_, err := common.GetObjectFromNode(t, compose.ContainerURI(2), "Article", articleIDs[0], "node2")
+			require.Equal(t, &objects.ObjectsClassGetNotFound{}, err)
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			require.Nil(t, compose.StartAt(ctx, 3))
+		})
+	})
+
+	t.Run("BatchAllObjects", func(t *testing.T) {
+		t.Run("OnNode-3", func(t *testing.T) {
+			common.DeleteObjects(t, compose.ContainerURI(3),
+				"Article", []string{"title"}, "Article#*", types.ConsistencyLevelAll)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("OnNode-1", func(t *testing.T) {
+			resp := common.GQLGet(t, compose.ContainerURI(1), "Article", types.ConsistencyLevelOne)
+			require.Empty(t, resp)
+		})
+
+		t.Run("OnNode-2", func(t *testing.T) {
+			resp := common.GQLGet(t, compose.ContainerURI(2), "Article", types.ConsistencyLevelOne)
+			require.Empty(t, resp)
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			require.Nil(t, compose.StartAt(ctx, 3))
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/read_repair/graphql_test.go

@@ -0,0 +1,133 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"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"
+)
+
+func (suite *ReplicationTestSuite) TestGraphqlSearch() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithText2VecContextionary().
+		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.ContainerURI(1))
+	paragraphClass := articles.ParagraphsClass()
+	paragraphClass.Vectorizer = "text2vec-contextionary"
+	articleClass := articles.ArticlesClass()
+
+	t.Run("CreateSchema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 2,
+		}
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 2,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	t.Run("InsertParagraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.ContainerURI(1), batch)
+	})
+
+	t.Run("InsertArticles", func(t *testing.T) {
+		batch := make([]*models.Object, len(articleIDs))
+		for i, id := range articleIDs {
+			batch[i] = articles.NewArticle().
+				WithID(id).
+				WithTitle(fmt.Sprintf("Article#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.ContainerURI(2), batch)
+	})
+
+	t.Run("StopNode-2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("get consistent search results with ONE (1/2 nodes up)", func(t *testing.T) {
+		resp := common.GQLGet(t, compose.ContainerURI(1), paragraphClass.Class, types.ConsistencyLevelOne)
+		checkResultsConsistency(t, resp, true)
+	})
+
+	t.Run("RestartNode-2", func(t *testing.T) {
+		err = compose.StartAt(ctx, 2)
+		require.Nil(t, err)
+	})
+
+	t.Run("get consistent search results with ALL (2/2 nodes up)", func(t *testing.T) {
+		resp := common.GQLGet(t, compose.ContainerURI(1), paragraphClass.Class, types.ConsistencyLevelAll)
+		checkResultsConsistency(t, resp, true)
+	})
+
+	t.Run("get consistent search results with QUORUM (2/2 nodes up)", func(t *testing.T) {
+		resp := common.GQLGet(t, compose.ContainerURI(1), paragraphClass.Class, types.ConsistencyLevelQuorum)
+		checkResultsConsistency(t, resp, true)
+	})
+
+	t.Run("get consistent search results with ONE (2/2 nodes up)", func(t *testing.T) {
+		resp := common.GQLGet(t, compose.ContainerURI(1), paragraphClass.Class, types.ConsistencyLevelOne)
+		checkResultsConsistency(t, resp, true)
+	})
+
+	t.Run("get consistent search results with ONE (2/2 nodes up)", func(t *testing.T) {
+		resp := common.GQLGet(t, compose.ContainerURI(1), paragraphClass.Class, types.ConsistencyLevelOne)
+		require.GreaterOrEqual(t, len(resp), 1)
+		vec := resp[0].(map[string]interface{})["_additional"].(map[string]interface{})["vector"].([]interface{})
+		resp = common.GQLGetNearVec(t, compose.ContainerURI(1), paragraphClass.Class, vec, types.ConsistencyLevelQuorum)
+		checkResultsConsistency(t, resp, true)
+	})
+}
+
+func checkResultsConsistency(t *testing.T, results []interface{}, expectConsistent bool) {
+	for _, res := range results {
+		addl := res.(map[string]interface{})["_additional"].(map[string]interface{})
+		if expectConsistent {
+			assert.True(t, addl["isConsistent"].(bool))
+		} else {
+			assert.False(t, addl["isConsistent"].(bool))
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/read_repair/multi_tenancy_test.go

@@ -0,0 +1,287 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/objects"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema/crossref"
+	"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"
+)
+
+const (
+	tenantID = strfmt.UUID("45e9e17e-8102-4011-95f0-3079ca188bbf")
+)
+
+func (suite *ReplicationTestSuite) TestMultiTenancyEnabled() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		With3NodeCluster().
+		WithText2VecContextionary().
+		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.ContainerURI(1))
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	t.Run("CreateSchema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 3,
+		}
+		paragraphClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+			Enabled: true,
+		}
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 3,
+		}
+		articleClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+			Enabled: true,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	time.Sleep(1 * time.Second) // remove once eventual consistency has been addressed
+
+	t.Run("AddTenants", func(t *testing.T) {
+		tenants := []*models.Tenant{{Name: tenantID.String()}}
+		helper.CreateTenants(t, paragraphClass.Class, tenants)
+		helper.CreateTenants(t, articleClass.Class, tenants)
+	})
+
+	t.Run("InsertParagraphsBatch", func(t *testing.T) {
+		t.Run("OnNode-3", func(t *testing.T) {
+			batch := make([]*models.Object, len(paragraphIDs))
+			for i, id := range paragraphIDs {
+				batch[i] = articles.NewParagraph().
+					WithID(id).
+					WithContents(fmt.Sprintf("paragraph#%d", i)).
+					WithTenant(tenantID.String()).
+					Object()
+			}
+			common.CreateTenantObjects(t, compose.ContainerURI(3), batch)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("ObjectsExistOnNode-1", func(t *testing.T) {
+			count := common.CountTenantObjects(t, compose.ContainerURI(1),
+				"Paragraph", tenantID.String())
+			assert.Equal(t, int64(len(paragraphIDs)), count)
+		})
+
+		t.Run("ObjectsExistOnNode-2", func(t *testing.T) {
+			count := common.CountTenantObjects(t, compose.ContainerURI(2),
+				"Paragraph", tenantID.String())
+			assert.Equal(t, int64(len(paragraphIDs)), count)
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			common.StartNodeAt(ctx, t, compose, 3)
+			time.Sleep(time.Second)
+		})
+	})
+
+	t.Run("InsertArticlesIndividually", func(t *testing.T) {
+		t.Run("CreateObjectsOnNode-3", func(t *testing.T) {
+			for i, id := range articleIDs {
+				obj := articles.NewArticle().
+					WithID(id).
+					WithTitle(fmt.Sprintf("Article#%d", i)).
+					WithTenant(tenantID.String()).
+					Object()
+				common.CreateObjectCL(t, compose.ContainerURI(3), obj, types.ConsistencyLevelQuorum)
+			}
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			time.Sleep(time.Second)
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("ObjectsExistOnNode-1", func(t *testing.T) {
+			count := common.CountTenantObjects(t, compose.ContainerURI(1),
+				"Article", tenantID.String())
+			assert.Equal(t, int64(len(articleIDs)), count)
+		})
+		t.Run("ObjectsExistOnNode-2", func(t *testing.T) {
+			count := common.CountTenantObjects(t, compose.ContainerURI(2),
+				"Article", tenantID.String())
+			assert.Equal(t, int64(len(articleIDs)), count)
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			common.StartNodeAt(ctx, t, compose, 3)
+			time.Sleep(time.Second)
+		})
+	})
+
+	t.Run("AddReferences", func(t *testing.T) {
+		refs := make([]*models.BatchReference, len(articleIDs))
+		for i := range articleIDs {
+			refs[i] = &models.BatchReference{
+				From:   strfmt.URI(crossref.NewSource("Article", "hasParagraphs", articleIDs[i]).String()),
+				To:     strfmt.URI(crossref.NewLocalhost("Paragraph", paragraphIDs[i]).String()),
+				Tenant: tenantID.String(),
+			}
+		}
+
+		t.Run("AddReferencesToNode-3", func(t *testing.T) {
+			common.AddTenantReferences(t, compose.ContainerURI(3), refs)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("ReferencesExistsONNode-2", func(t *testing.T) {
+			type additional struct {
+				ID strfmt.UUID `json:"id"`
+			}
+
+			type article struct {
+				Additional    additional `json:"_additional"`
+				HasParagraphs []struct {
+					Additional additional `json:"_additional"`
+				} `json:"hasParagraphs"`
+			}
+
+			// maps article id to referenced paragraph id
+			refPairs := make(map[strfmt.UUID]strfmt.UUID)
+			resp := common.GQLTenantGet(t, compose.ContainerURI(2), "Article", types.ConsistencyLevelOne,
+				tenantID.String(), "_additional{id}", "hasParagraphs {... on Paragraph {_additional{id}}}")
+			assert.Len(t, resp, len(articleIDs))
+
+			for _, r := range resp {
+				b, err := json.Marshal(r)
+				require.Nil(t, err)
+				var art article
+				err = json.Unmarshal(b, &art)
+				require.Nil(t, err)
+				require.Len(t, art.HasParagraphs, 1)
+				refPairs[art.Additional.ID] = art.HasParagraphs[0].Additional.ID
+			}
+
+			for i := range articleIDs {
+				paragraphID, ok := refPairs[articleIDs[i]]
+				require.True(t, ok, "expected %q to be in refPairs: %+v", articleIDs[i], refPairs)
+				assert.Equal(t, paragraphIDs[i], paragraphID)
+			}
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			common.StartNodeAt(ctx, t, compose, 3)
+			time.Sleep(time.Second)
+		})
+	})
+
+	t.Run("UpdateObject", func(t *testing.T) {
+		before, err := common.GetTenantObject(t, compose.ContainerURI(1), "Article", articleIDs[0], tenantID.String())
+		require.Nil(t, err)
+		newTitle := "Article#9000"
+
+		t.Run("OnNode-3", func(t *testing.T) {
+			patch := &models.Object{
+				ID:         before.ID,
+				Class:      "Article",
+				Properties: map[string]interface{}{"title": newTitle},
+				Tenant:     tenantID.String(),
+			}
+			common.UpdateObjectCL(t, compose.ContainerURI(3), patch, types.ConsistencyLevelQuorum)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("PatchedOnNode-1", func(t *testing.T) {
+			after, err := common.GetTenantObjectFromNode(t, compose.ContainerURI(1),
+				"Article", articleIDs[0], "node1", tenantID.String())
+			require.Nil(t, err)
+
+			newVal, ok := after.Properties.(map[string]interface{})["title"]
+			require.True(t, ok)
+			assert.Equal(t, newTitle, newVal)
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			common.StartNodeAt(ctx, t, compose, 3)
+			time.Sleep(time.Second)
+		})
+	})
+
+	t.Run("DeleteObject", func(t *testing.T) {
+		t.Run("OnNode-1", func(t *testing.T) {
+			common.DeleteTenantObject(t, compose.ContainerURI(1), "Article", articleIDs[0], tenantID.String(), types.ConsistencyLevelAll)
+		})
+
+		t.Run("StopNode-3", func(t *testing.T) {
+			common.StartNodeAt(ctx, t, compose, 3)
+		})
+
+		t.Run("OnNode-2", func(t *testing.T) {
+			_, err := common.GetTenantObjectFromNode(t, compose.ContainerURI(2),
+				"Article", articleIDs[0], "node2", tenantID.String())
+			assert.Equal(t, &objects.ObjectsClassGetNotFound{}, err)
+		})
+
+		t.Run("RestartNode-3", func(t *testing.T) {
+			common.StartNodeAt(ctx, t, compose, 3)
+		})
+	})
+
+	t.Run("BatchAllObjects", func(t *testing.T) {
+		t.Run("OnNode-2", func(t *testing.T) {
+			common.DeleteTenantObjects(t, compose.ContainerURI(2),
+				"Article", []string{"title"}, "Article#*", tenantID.String(), types.ConsistencyLevelAll)
+		})
+
+		t.Run("StopNode-2", func(t *testing.T) {
+			common.StopNodeAt(ctx, t, compose, 2)
+		})
+
+		t.Run("OnNode-1", func(t *testing.T) {
+			count := common.CountTenantObjects(t, compose.ContainerURI(1), "Article", tenantID.String())
+			assert.Zero(t, count)
+		})
+
+		t.Run("RestartNode-2", func(t *testing.T) {
+			common.StartNodeAt(ctx, t, compose, 2)
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/read_repair/read_repair_deleteonconflict_test.go

@@ -0,0 +1,217 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"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"
+)
+
+func (suite *ReplicationTestSuite) TestReadRepairDeleteOnConflict() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		With3NodeCluster().
+		WithText2VecContextionary().
+		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, 15*time.Minute)
+	defer cancel()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:           3,
+			DeletionStrategy: models.ReplicationConfigDeletionStrategyDeleteOnConflict,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:           3,
+			DeletionStrategy: models.ReplicationConfigDeletionStrategyDeleteOnConflict,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	t.Run("insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviate().URI(), batch)
+	})
+
+	t.Run("insert articles", func(t *testing.T) {
+		batch := make([]*models.Object, len(articleIDs))
+		for i, id := range articleIDs {
+			batch[i] = articles.NewArticle().
+				WithID(id).
+				WithTitle(fmt.Sprintf("Article#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviateNode2().URI(), batch)
+	})
+
+	t.Run("stop node 2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	repairObj := models.Object{
+		ID:    "e5390693-5a22-44b8-997d-2a213aaf5884",
+		Class: "Paragraph",
+		Properties: map[string]interface{}{
+			"contents": "a new paragraph",
+		},
+	}
+
+	t.Run("add new object to node one with node2 down", func(t *testing.T) {
+		common.CreateObjectCL(t, compose.GetWeaviate().URI(), &repairObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 2", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("run fetch to trigger read repair", func(t *testing.T) {
+		_, err := common.GetObjectCL(t, compose.GetWeaviate().URI(), repairObj.Class, repairObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+	})
+
+	t.Run("require new object read repair was made", func(t *testing.T) {
+		resp, err := common.GetObjectCL(t, compose.GetWeaviateNode2().URI(),
+			repairObj.Class, repairObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.Equal(t, repairObj.ID, resp.ID)
+		require.Equal(t, repairObj.Class, resp.Class)
+		require.EqualValues(t, repairObj.Properties, resp.Properties)
+		require.EqualValues(t, repairObj.Vector, resp.Vector)
+	})
+
+	t.Run("stop node 3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	replaceObj := repairObj
+	replaceObj.Properties = map[string]interface{}{
+		"contents": "this paragraph was replaced",
+	}
+
+	t.Run("replace object with node3 down", func(t *testing.T) {
+		common.UpdateObjectCL(t, compose.GetWeaviateNode2().URI(), &replaceObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("run exists to trigger read repair", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+
+	t.Run("require updated object read repair was made", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode3().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+
+		resp, err := common.GetObjectCL(t, compose.GetWeaviateNode3().URI(),
+			repairObj.Class, repairObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.Equal(t, replaceObj.ID, resp.ID)
+		require.Equal(t, replaceObj.Class, resp.Class)
+		require.EqualValues(t, replaceObj.Properties, resp.Properties)
+		require.EqualValues(t, replaceObj.Vector, resp.Vector)
+	})
+
+	t.Run("stop node 2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("delete article with consistency level ONE and node2 down", func(t *testing.T) {
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.DeleteObjectCL(t, replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 2", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("stop node3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	replaceObj.Properties = map[string]interface{}{
+		"contents": "this paragraph was replaced for second time",
+	}
+
+	t.Run("replace object in node2 with node3 down", func(t *testing.T) {
+		common.UpdateObjectCL(t, compose.GetWeaviateNode2().URI(), &replaceObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("deleted article should not be present in node3", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode3().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.False(t, exists)
+	})
+
+	t.Run("run exists to trigger read repair with deleted object resolution", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+		require.False(t, exists)
+	})
+
+	t.Run("deleted article should not be present in node3", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode3().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.False(t, exists)
+	})
+
+	t.Run("deleted article should not be present in node2", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.False(t, exists)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/read_repair/read_repair_test.go

@@ -0,0 +1,189 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"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"
+)
+
+func (suite *ReplicationTestSuite) TestReadRepair() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		With3NodeCluster().
+		WithText2VecContextionary().
+		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.ContainerURI(1))
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	t.Run("CreateSchema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 3,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor: 3,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	time.Sleep(time.Second) // remove once eventual consistency has been addressed
+
+	t.Run("InsertParagraphs/Node-1", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.ContainerURI(1), batch)
+	})
+
+	t.Run("InsertArticles/Node-3", func(t *testing.T) {
+		batch := make([]*models.Object, len(articleIDs))
+		for i, id := range articleIDs {
+			batch[i] = articles.NewArticle().
+				WithID(id).
+				WithTitle(fmt.Sprintf("Article#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.ContainerURI(3), batch)
+	})
+
+	t.Run("StopNode-3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	repairObj := models.Object{
+		ID:    "e5390693-5a22-44b8-997d-2a213aaf5884",
+		Class: "Paragraph",
+		Properties: map[string]interface{}{
+			"contents": "a new paragraph",
+		},
+	}
+	t.Run("AddObjectToNode-1", func(t *testing.T) {
+		common.CreateObjectCL(t, compose.ContainerURI(1), &repairObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("RestartNode-3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+		time.Sleep(time.Second)
+	})
+
+	t.Run("TriggerRepairQuorumOnNode-3", func(t *testing.T) {
+		resp, err := common.GetObjectCL(t, compose.ContainerURI(3),
+			repairObj.Class, repairObj.ID, types.ConsistencyLevelQuorum)
+		require.Nil(t, err)
+		require.Equal(t, repairObj.ID, resp.ID)
+		require.Equal(t, repairObj.Class, resp.Class)
+		require.EqualValues(t, repairObj.Properties, resp.Properties)
+		require.EqualValues(t, repairObj.Vector, resp.Vector)
+	})
+
+	t.Run("StopNode-3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	replaceObj := repairObj
+	replaceObj.Properties = map[string]interface{}{
+		"contents": "this paragraph was replaced",
+	}
+
+	t.Run("ReplaceObjectOneOnNode2", func(t *testing.T) {
+		common.UpdateObjectCL(t, compose.ContainerURI(2), &replaceObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("RestartNode-3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("TriggerRepairAllOnNode1", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.ContainerURI(1),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+
+	t.Run("UpdatedObjectRepairedOnNode-3", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.ContainerURI(3),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+
+		resp, err := common.GetObjectCL(t, compose.ContainerURI(1),
+			repairObj.Class, repairObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.Equal(t, replaceObj.ID, resp.ID)
+		require.Equal(t, replaceObj.Class, resp.Class)
+		require.EqualValues(t, replaceObj.Properties, resp.Properties)
+		require.EqualValues(t, replaceObj.Vector, resp.Vector)
+	})
+
+	t.Run("stop node2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("delete article with consistency level ONE and node2 down", func(t *testing.T) {
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.DeleteObjectCL(t, replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node2", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("deleted article should be present in node2", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+
+	t.Run("run exists to trigger read repair with deleted object resolution", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+		require.False(t, exists)
+	})
+
+	t.Run("deleted article should still be present in node2 (object deletion is not resolved)", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/read_repair/read_repair_timebasedresolution_test.go

@@ -0,0 +1,225 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"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"
+)
+
+func (suite *ReplicationTestSuite) TestReadRepairTimebasedResolution() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		With3NodeCluster().
+		WithText2VecContextionary().
+		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, 15*time.Minute)
+	defer cancel()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:           3,
+			DeletionStrategy: models.ReplicationConfigDeletionStrategyTimeBasedResolution,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:           3,
+			DeletionStrategy: models.ReplicationConfigDeletionStrategyTimeBasedResolution,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	t.Run("insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviate().URI(), batch)
+	})
+
+	t.Run("insert articles", func(t *testing.T) {
+		batch := make([]*models.Object, len(articleIDs))
+		for i, id := range articleIDs {
+			batch[i] = articles.NewArticle().
+				WithID(id).
+				WithTitle(fmt.Sprintf("Article#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviateNode2().URI(), batch)
+	})
+
+	t.Run("stop node 2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	repairObj := models.Object{
+		ID:    "e5390693-5a22-44b8-997d-2a213aaf5884",
+		Class: "Paragraph",
+		Properties: map[string]interface{}{
+			"contents": "a new paragraph",
+		},
+	}
+
+	t.Run("add new object to node1 with node2 down", func(t *testing.T) {
+		common.CreateObjectCL(t, compose.GetWeaviate().URI(), &repairObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 2", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("run fetch to trigger read repair", func(t *testing.T) {
+		_, err := common.GetObjectCL(t, compose.GetWeaviate().URI(), repairObj.Class, repairObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+	})
+
+	t.Run("require new object read repair was made", func(t *testing.T) {
+		resp, err := common.GetObjectCL(t, compose.GetWeaviateNode2().URI(),
+			repairObj.Class, repairObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.Equal(t, repairObj.ID, resp.ID)
+		require.Equal(t, repairObj.Class, resp.Class)
+		require.EqualValues(t, repairObj.Properties, resp.Properties)
+		require.EqualValues(t, repairObj.Vector, resp.Vector)
+	})
+
+	replaceObj := repairObj
+	replaceObj.Properties = map[string]interface{}{
+		"contents": "this paragraph was replaced",
+	}
+
+	t.Run("stop node 3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("replace object", func(t *testing.T) {
+		common.UpdateObjectCL(t, compose.GetWeaviateNode2().URI(), &replaceObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("run exists to trigger read repair", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+
+	t.Run("require updated object read repair was made", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode3().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+
+		resp, err := common.GetObjectCL(t, compose.GetWeaviateNode3().URI(),
+			repairObj.Class, repairObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.Equal(t, replaceObj.ID, resp.ID)
+		require.Equal(t, replaceObj.Class, resp.Class)
+		require.EqualValues(t, replaceObj.Properties, resp.Properties)
+		require.EqualValues(t, replaceObj.Vector, resp.Vector)
+	})
+
+	t.Run("stop node 2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("delete article with consistency level ONE and node2 down", func(t *testing.T) {
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.DeleteObjectCL(t, replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 2", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("stop node3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	replaceObj.Properties = map[string]interface{}{
+		"contents": "this paragraph was replaced for second time",
+	}
+
+	t.Run("replace object in node2", func(t *testing.T) {
+		err := common.UpdateObjectCL(t, compose.GetWeaviateNode2().URI(), &replaceObj, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+	})
+
+	t.Run("deleted article should be present in node2", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+
+	t.Run("restart node 3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("deleted article should not be present in node3", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode3().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.False(t, exists)
+	})
+
+	t.Run("run exists to trigger read repair with deleted object resolution", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelAll)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+
+	t.Run("deleted article should be present in node2", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode2().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+
+	t.Run("deleted article should be present in node3", func(t *testing.T) {
+		exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode3().URI(),
+			replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+		require.Nil(t, err)
+		require.True(t, exists)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/conflicts_test.go

@@ -0,0 +1,213 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateConflictsCOPY() {
+	t := suite.T()
+
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	helper.DeleteClass(t, paragraphClass.Class)
+	helper.CreateClass(t, paragraphClass)
+
+	batch := make([]*models.Object, 10000)
+	for i := 0; i < 10000; i++ {
+		batch[i] = articles.NewParagraph().
+			WithContents(fmt.Sprintf("paragraph#%d", i)).
+			Object()
+	}
+	helper.CreateObjectsBatch(t, batch)
+
+	req := getRequest(t, paragraphClass.Class)
+
+	var id strfmt.UUID
+	t.Run("create COPY replication operation and wait until the replica is in the sharding state", func(t *testing.T) {
+		created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(req), nil)
+		require.Nil(t, err)
+		id = *created.Payload.ID
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			shardingState, err := helper.Client(t).Replication.
+				GetCollectionShardingState(replication.
+					NewGetCollectionShardingStateParams().
+					WithCollection(&paragraphClass.Class), nil)
+			require.Nil(t, err)
+			replicaPresent := false
+			for _, shard := range shardingState.Payload.ShardingState.Shards {
+				if shard.Shard != *req.Shard {
+					continue
+				}
+				for _, replica := range shard.Replicas {
+					if replica == *req.TargetNode {
+						replicaPresent = true
+						break
+					}
+				}
+			}
+			require.True(ct, replicaPresent)
+		}, 60*time.Second, 100*time.Millisecond, "replica should be present in the destination node")
+	})
+
+	t.Run("verify uncancelable state when getting details", func(t *testing.T) {
+		details, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+		require.Nil(t, err)
+		require.True(t, details.Payload.Uncancelable)
+	})
+
+	t.Run("fail to cancel replication operation due to operation being uncancellable", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.CancelReplication(replication.NewCancelReplicationParams().WithID(id), nil)
+		require.NotNil(t, err)
+		require.IsType(t, &replication.CancelReplicationConflict{}, err)
+	})
+
+	// Wait until the replication operation is READY
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		status, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+		require.Nil(t, err)
+		require.Equal(ct, "READY", status.Payload.Status.State)
+	}, 180*time.Second, 100*time.Millisecond, "Replication operation should be in READY state")
+
+	t.Run("succeed to delete the replication operation without a conflict", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.DeleteReplication(replication.NewDeleteReplicationParams().WithID(id), nil)
+		require.Nil(t, err)
+	})
+
+	t.Run("ensure target and source shards are still there", func(t *testing.T) {
+		verbose := verbosity.OutputVerbose
+		nodes, err := helper.Client(t).Nodes.NodesGetClass(nodes.NewNodesGetClassParams().WithOutput(&verbose).WithClassName(paragraphClass.Class), nil)
+		require.Nil(t, err)
+		foundSrc := false
+		foundDst := false
+		for _, node := range nodes.Payload.Nodes {
+			if *req.SourceNode == node.Name {
+				for _, shard := range node.Shards {
+					if shard.Name == *req.Shard {
+						foundSrc = true
+					}
+				}
+			}
+			if *req.TargetNode == node.Name {
+				for _, shard := range node.Shards {
+					if shard.Name == *req.Shard {
+						foundDst = true
+					}
+				}
+			}
+		}
+		require.True(t, foundSrc, "source shard should be there")
+		require.True(t, foundDst, "destination shard should be there")
+	})
+}
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateConflictsMOVE() {
+	t := suite.T()
+
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	helper.DeleteClass(t, paragraphClass.Class)
+	helper.CreateClass(t, paragraphClass)
+
+	req := getRequest(t, paragraphClass.Class)
+
+	move := "MOVE"
+	req.Type = &move
+	// Create MOVE replication operation and wait until the shard is in the sharding state (meaning it is uncancellable)
+	created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(req), nil)
+	require.Nil(t, err)
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		shardingState, err := helper.Client(t).Replication.
+			GetCollectionShardingState(replication.
+				NewGetCollectionShardingStateParams().
+				WithCollection(&paragraphClass.Class), nil)
+		require.Nil(t, err)
+		replicaPresent := false
+		for _, shard := range shardingState.Payload.ShardingState.Shards {
+			if shard.Shard != *req.Shard {
+				continue
+			}
+			for _, replica := range shard.Replicas {
+				if replica == *req.TargetNode {
+					replicaPresent = true
+					break
+				}
+			}
+		}
+		require.True(ct, replicaPresent)
+	}, 60*time.Second, 100*time.Millisecond, "replica should be present in the destination node")
+	id := *created.Payload.ID
+
+	t.Run("fail to cancel replication operation due to uncancellable state", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.CancelReplication(replication.NewCancelReplicationParams().WithID(id), nil)
+		require.NotNil(t, err)
+		require.IsType(t, &replication.CancelReplicationConflict{}, err)
+	})
+
+	t.Run("fail to delete replication operation due to uncancellable state", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.DeleteReplication(replication.NewDeleteReplicationParams().WithID(id), nil)
+		require.NotNil(t, err)
+		require.IsType(t, &replication.DeleteReplicationConflict{}, err)
+	})
+
+	// Wait until the replication operation is READY
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		status, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+		require.Nil(t, err)
+		require.Equal(ct, "READY", status.Payload.Status.State)
+	}, 180*time.Second, 100*time.Millisecond, "Replication operation should be in READY state")
+
+	t.Run("succeed to delete the replication operation without a conflict", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.DeleteReplication(replication.NewDeleteReplicationParams().WithID(id), nil)
+		require.Nil(t, err)
+	})
+
+	// Ensure that the source shard is still there and the destination shard is there
+	t.Run("ensure target and source shards are still there", func(t *testing.T) {
+		verbose := verbosity.OutputVerbose
+		nodes, err := helper.Client(t).Nodes.NodesGetClass(nodes.NewNodesGetClassParams().WithOutput(&verbose).WithClassName(paragraphClass.Class), nil)
+		require.Nil(t, err)
+		foundSrc := false
+		foundDst := false
+		for _, node := range nodes.Payload.Nodes {
+			if *req.SourceNode == node.Name {
+				for _, shard := range node.Shards {
+					if shard.Name == *req.Shard {
+						foundSrc = true
+					}
+				}
+			}
+			if *req.TargetNode == node.Name {
+				for _, shard := range node.Shards {
+					if shard.Name == *req.Shard {
+						foundDst = true
+					}
+				}
+			}
+		}
+		require.False(t, foundSrc, "source replica should not be there")
+		require.True(t, foundDst, "destination replica should be there")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/delete_class_test.go

@@ -0,0 +1,98 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/cluster/proto/api"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationDeletingClassCleansUpOperations() {
+	t := suite.T()
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+
+	paragraphClass := articles.ParagraphsClass()
+
+	stateToDeleteIn := []api.ShardReplicationState{
+		api.REGISTERED,
+		api.HYDRATING,
+		api.FINALIZING,
+	}
+
+	for _, state := range stateToDeleteIn {
+		helper.DeleteClass(t, paragraphClass.Class)
+		helper.CreateClass(t, paragraphClass)
+
+		t.Run("insert paragraphs", func(t *testing.T) {
+			batch := make([]*models.Object, 10000)
+			for i := 0; i < 10000; i++ {
+				batch[i] = articles.NewParagraph().
+					WithContents(fmt.Sprintf("paragraph#%d", i)).
+					Object()
+			}
+			helper.CreateObjectsBatch(t, batch)
+		})
+
+		var id strfmt.UUID
+		t.Run("create replication operation", func(t *testing.T) {
+			created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(getRequest(t, paragraphClass.Class)), nil)
+			require.Nil(t, err)
+			require.NotNil(t, created)
+			require.NotNil(t, created.Payload)
+			require.NotNil(t, created.Payload.ID)
+			id = *created.Payload.ID
+		})
+
+		if state != api.REGISTERED {
+			t.Run(fmt.Sprintf("wait until op is in %s state", state), func(t *testing.T) {
+				assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+					details, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+					require.Nil(ct, err)
+					require.Equal(ct, state.String(), details.Payload.Status.State)
+				}, 60*time.Second, 10*time.Millisecond, "replication operation should be in %s state", state)
+			})
+		}
+
+		t.Run("delete class", func(t *testing.T) {
+			helper.DeleteClass(t, paragraphClass.Class)
+		})
+
+		t.Run("wait for replication operation to be deleted", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+				_, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+				require.NotNil(ct, err)
+				assert.IsType(ct, replication.NewReplicationDetailsNotFound(), err)
+			}, 120*time.Second, 1*time.Second, fmt.Sprintf("replication operation should be deleted: %s", id))
+		})
+
+		t.Run("assert that async replication is not running in any of the nodes", func(t *testing.T) {
+			nodes, err := helper.Client(t).Nodes.NodesGet(nodes.NewNodesGetParams(), nil)
+			require.Nil(t, err)
+			for _, node := range nodes.Payload.Nodes {
+				for _, shard := range node.Shards {
+					require.Len(t, shard.AsyncReplicationStatus, 0)
+				}
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/delete_tenant_test.go

@@ -0,0 +1,193 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"fmt"
+	"slices"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/cluster/proto/api"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationDeletingTenantCleansUpOperations() {
+	t := suite.T()
+
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	paragraphClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+		AutoTenantCreation: true,
+		Enabled:            true,
+	}
+
+	tenant1 := "tenant1"
+	tenant2 := "tenant2"
+
+	stateToDeleteIn := []api.ShardReplicationState{
+		api.REGISTERED,
+		api.HYDRATING,
+		api.FINALIZING,
+	}
+
+	for _, state := range stateToDeleteIn {
+		t.Run(fmt.Sprintf("delete tenant when op is %s", state), func(t *testing.T) {
+			helper.DeleteClass(t, paragraphClass.Class)
+			helper.CreateClass(t, paragraphClass)
+
+			t.Run(fmt.Sprintf("insert paragraphs into %s", tenant1), func(t *testing.T) {
+				batch := make([]*models.Object, 5000)
+				for i := 0; i < 5000; i++ {
+					batch[i] = (*models.Object)(articles.NewParagraph().
+						WithContents(fmt.Sprintf("paragraph#%d", i)).
+						WithTenant(tenant1).
+						Object())
+				}
+				helper.CreateObjectsBatch(t, batch)
+			})
+
+			t.Run(fmt.Sprintf("insert paragraphs into %s", tenant2), func(t *testing.T) {
+				batch := make([]*models.Object, 5000)
+				for i := 0; i < 5000; i++ {
+					batch[i] = (*models.Object)(articles.NewParagraph().
+						WithContents(fmt.Sprintf("paragraph#%d", i)).
+						WithTenant(tenant2).
+						Object())
+				}
+				helper.CreateObjectsBatch(t, batch)
+			})
+
+			var id1 strfmt.UUID
+			t.Run(fmt.Sprintf("create replication operation for %s", tenant1), func(t *testing.T) {
+				created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(getMTRequest(t, paragraphClass.Class, tenant1)), nil)
+				require.Nil(t, err)
+				require.NotNil(t, created)
+				require.NotNil(t, created.Payload)
+				require.NotNil(t, created.Payload.ID)
+				id1 = *created.Payload.ID
+			})
+
+			var id2 strfmt.UUID
+			t.Run(fmt.Sprintf("create replication operation for %s", tenant2), func(t *testing.T) {
+				created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(getMTRequest(t, paragraphClass.Class, tenant2)), nil)
+				require.Nil(t, err)
+				require.NotNil(t, created)
+				require.NotNil(t, created.Payload)
+				require.NotNil(t, created.Payload.ID)
+				id2 = *created.Payload.ID
+			})
+
+			if state != api.REGISTERED {
+				t.Run(fmt.Sprintf("wait until op for %s is in %s state", tenant1, state), func(t *testing.T) {
+					assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+						details, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id1), nil)
+						require.Nil(ct, err)
+						require.Equal(ct, state.String(), details.Payload.Status.State)
+					}, 30*time.Second, 100*time.Millisecond, "replication operation should be in %s state", state)
+				})
+			}
+
+			t.Run(fmt.Sprintf("delete %s", tenant1), func(t *testing.T) {
+				helper.DeleteTenants(t, paragraphClass.Class, []string{tenant1})
+			})
+
+			t.Run("wait for replication operation to be deleted", func(t *testing.T) {
+				assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+					_, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id1), nil)
+					require.NotNil(ct, err)
+					assert.IsType(ct, replication.NewReplicationDetailsNotFound(), err)
+				}, 30*time.Second, 1*time.Second, "replication operation should be deleted")
+			})
+
+			t.Run(fmt.Sprintf("ensure that the replication operation for %s is still there", tenant2), func(t *testing.T) {
+				details, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id2), nil)
+				require.Nil(t, err)
+				require.NotNil(t, details)
+				require.NotNil(t, details.Payload)
+				require.NotNil(t, details.Payload.ID)
+				require.Equal(t, id2, *details.Payload.ID)
+			})
+
+			// Required so we can loop again for other replication operation stages without waiting for it to complete
+			// and potentially colliding with replication ops on a per-shard basis, which is a 500
+
+			t.Run(fmt.Sprintf("delete %s", tenant2), func(t *testing.T) {
+				helper.DeleteTenants(t, paragraphClass.Class, []string{tenant2})
+			})
+
+			t.Run("wait for replication operation to be deleted", func(t *testing.T) {
+				assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+					_, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id2), nil)
+					require.NotNil(ct, err)
+					assert.IsType(ct, replication.NewReplicationDetailsNotFound(), err)
+				}, 30*time.Second, 1*time.Second, "replication operation should be deleted")
+			})
+
+			t.Run("assert that async replication is not running in any of the nodes", func(t *testing.T) {
+				nodes, err := helper.Client(t).Nodes.
+					NodesGetClass(nodes.NewNodesGetClassParams().WithClassName(paragraphClass.Class), nil)
+				require.Nil(t, err)
+				for _, node := range nodes.Payload.Nodes {
+					for _, shard := range node.Shards {
+						require.Len(t, shard.AsyncReplicationStatus, 0)
+					}
+				}
+			})
+		})
+	}
+}
+
+func getMTRequest(t *testing.T, className, tenant string) *models.ReplicationReplicateReplicaRequest {
+	verbosity := verbosity.OutputVerbose
+	nodes, err := helper.Client(t).Nodes.NodesGetClass(nodes.NewNodesGetClassParams().WithOutput(&verbosity).WithClassName(className), nil)
+	require.Nil(t, err)
+
+	// find node with tenant
+	sourceNode := ""
+	for _, node := range nodes.Payload.Nodes {
+		for _, shard := range node.Shards {
+			if shard.Name == tenant {
+				sourceNode = node.Name
+				break
+			}
+		}
+	}
+
+	// find node without tenant
+	destinationNode := ""
+	for _, node := range nodes.Payload.Nodes {
+		shards := make([]string, 0)
+		for _, shard := range node.Shards {
+			shards = append(shards, shard.Name)
+		}
+		if sourceNode != node.Name && !slices.Contains(shards, tenant) {
+			destinationNode = node.Name
+			break
+		}
+	}
+
+	return &models.ReplicationReplicateReplicaRequest{
+		Collection: &className,
+		SourceNode: &sourceNode,
+		TargetNode: &destinationNode,
+		Shard:      &tenant,
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/endpoints_test.go

@@ -0,0 +1,327 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"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"
+	"github.com/weaviate/weaviate/cluster/proto/api"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"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
+	compose *docker.DockerCompose
+	down    func()
+}
+
+func (suite *ReplicationTestSuite) SetupSuite() {
+	t := suite.T()
+	t.Setenv("TEST_WEAVIATE_IMAGE", "weaviate/test-server")
+
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithWeaviateEnv("REPLICATION_ENGINE_MAX_WORKERS", "100").
+		WithWeaviateEnv("REPLICA_MOVEMENT_MINIMUM_ASYNC_WAIT", "5s").
+		Start(mainCtx)
+	require.Nil(t, err)
+	suite.compose = compose
+	suite.down = func() {
+		if err := compose.Terminate(mainCtx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}
+}
+
+func (suite *ReplicationTestSuite) TearDownSuite() {
+	if suite.down != nil {
+		suite.down()
+	}
+}
+
+func TestReplicationTestSuite(t *testing.T) {
+	suite.Run(t, new(ReplicationTestSuite))
+}
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateEndpoints() {
+	t := suite.T()
+
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	helper.DeleteClass(t, paragraphClass.Class)
+	helper.CreateClass(t, paragraphClass)
+
+	var id strfmt.UUID
+	t.Run("get collection sharding state", func(t *testing.T) {
+		shardingState, err := helper.Client(t).Replication.GetCollectionShardingState(replication.NewGetCollectionShardingStateParams().WithCollection(&paragraphClass.Class), nil)
+		require.Nil(t, err)
+		require.NotNil(t, shardingState)
+		require.NotNil(t, shardingState.Payload)
+		require.NotNil(t, shardingState.Payload.ShardingState)
+		require.NotNil(t, shardingState.Payload.ShardingState.Collection)
+		require.NotNil(t, shardingState.Payload.ShardingState.Shards)
+		require.Equal(t, paragraphClass.Class, shardingState.Payload.ShardingState.Collection)
+		require.Len(t, shardingState.Payload.ShardingState.Shards, 3)
+		for _, shard := range shardingState.Payload.ShardingState.Shards {
+			require.Len(t, shard.Replicas, 1)
+		}
+	})
+
+	t.Run("get collection and shard sharding state", func(t *testing.T) {
+		shard := getRequest(t, paragraphClass.Class).Shard
+		shardingState, err := helper.Client(t).Replication.GetCollectionShardingState(replication.NewGetCollectionShardingStateParams().WithCollection(&paragraphClass.Class).WithShard(shard), nil)
+		require.Nil(t, err)
+		require.NotNil(t, shardingState)
+		require.NotNil(t, shardingState.Payload)
+		require.NotNil(t, shardingState.Payload.ShardingState)
+		require.NotNil(t, shardingState.Payload.ShardingState.Collection)
+		require.NotNil(t, shardingState.Payload.ShardingState.Shards)
+		require.Equal(t, paragraphClass.Class, shardingState.Payload.ShardingState.Collection)
+		require.Len(t, shardingState.Payload.ShardingState.Shards, 1)
+		require.Equal(t, *shard, shardingState.Payload.ShardingState.Shards[0].Shard)
+		require.Len(t, shardingState.Payload.ShardingState.Shards[0].Replicas, 1)
+	})
+
+	t.Run("get sharding state for non-existing collection", func(t *testing.T) {
+		collection := "non-existing"
+		_, err := helper.Client(t).Replication.GetCollectionShardingState(replication.NewGetCollectionShardingStateParams().WithCollection(&collection), nil)
+		require.Error(t, err)
+		require.IsType(t, replication.NewGetCollectionShardingStateNotFound(), err)
+	})
+
+	t.Run("get sharding state for non-existing collection and shard", func(t *testing.T) {
+		collection := "non-existing"
+		shard := "non-existing"
+		_, err := helper.Client(t).Replication.GetCollectionShardingState(replication.NewGetCollectionShardingStateParams().WithCollection(&collection).WithShard(&shard), nil)
+		require.Error(t, err)
+		require.IsType(t, replication.NewGetCollectionShardingStateNotFound(), err)
+	})
+	t.Run("get sharding state for existing collection and non-existing shard", func(t *testing.T) {
+		shard := "non-existing"
+		_, err := helper.Client(t).Replication.GetCollectionShardingState(replication.NewGetCollectionShardingStateParams().WithCollection(&paragraphClass.Class).WithShard(&shard), nil)
+		require.Error(t, err)
+		require.IsType(t, replication.NewGetCollectionShardingStateNotFound(), err)
+	})
+
+	t.Run("create replication operation", func(t *testing.T) {
+		created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(getRequest(t, paragraphClass.Class)), nil)
+		require.Nil(t, err)
+		require.NotNil(t, created)
+		require.NotNil(t, created.Payload)
+		require.NotNil(t, created.Payload.ID)
+		id = *created.Payload.ID
+	})
+
+	t.Run("get replication operation", func(t *testing.T) {
+		includeHistory := true
+		details, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id).WithIncludeHistory(&includeHistory), nil)
+		require.Nil(t, err)
+		require.NotNil(t, details)
+		require.NotNil(t, details.Payload)
+		require.NotNil(t, details.Payload.ID)
+		require.False(t, details.Payload.ScheduledForCancel)
+		require.False(t, details.Payload.ScheduledForDelete)
+		require.False(t, details.Payload.Uncancelable)
+		require.Equal(t, id, *details.Payload.ID)
+		require.NotNil(t, details.Payload.WhenStartedUnixMs)
+		require.Less(t, details.Payload.WhenStartedUnixMs, time.Now().UnixMilli())
+		require.NotNil(t, details.Payload.Status.WhenStartedUnixMs)
+		require.Less(t, details.Payload.Status.WhenStartedUnixMs, time.Now().UnixMilli())
+		for _, status := range details.Payload.StatusHistory {
+			require.NotNil(t, status.WhenStartedUnixMs)
+			require.Less(t, status.WhenStartedUnixMs, time.Now().UnixMilli())
+		}
+	})
+
+	t.Run("get replication operation by collection", func(t *testing.T) {
+		details, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams().WithCollection(&paragraphClass.Class), nil)
+		require.Nil(t, err)
+		found := false
+		for _, op := range details.Payload {
+			if op.ID != nil && *op.ID == id {
+				found = true
+				break
+			}
+		}
+		require.True(t, found, "replication operation should be found by collection")
+	})
+
+	t.Run("get replication operation by collection and shard", func(t *testing.T) {
+		shard := getRequest(t, paragraphClass.Class).Shard
+		details, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams().WithCollection(&paragraphClass.Class).WithShard(shard), nil)
+		require.Nil(t, err)
+		found := false
+		for _, op := range details.Payload {
+			if op.ID != nil && *op.ID == id {
+				found = true
+				break
+			}
+		}
+		require.True(t, found, "replication operation should be found by collection")
+	})
+
+	t.Run("get replication operation by target node", func(t *testing.T) {
+		nodeID := getRequest(t, paragraphClass.Class).TargetNode
+		details, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams().WithTargetNode(nodeID), nil)
+		require.Nil(t, err)
+		found := false
+		for _, op := range details.Payload {
+			if op.ID != nil && *op.ID == id {
+				found = true
+				break
+			}
+		}
+		require.True(t, found, "replication operation should be found by collection")
+	})
+
+	t.Run("get non-existing replication operation", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(strfmt.UUID(uuid.New().String())), nil)
+		require.NotNil(t, err)
+		require.IsType(t, replication.NewReplicationDetailsNotFound(), err)
+	})
+
+	t.Run("list non-existing replication operations by collection", func(t *testing.T) {
+		collection := "non-existing"
+		res, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams().WithCollection(&collection), nil)
+		require.Nil(t, err)
+		require.Len(t, res.Payload, 0)
+	})
+
+	t.Run("list non-existing replication operations by collection and shard", func(t *testing.T) {
+		collection := "non-existing"
+		shard := "non-existing"
+		res, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams().WithCollection(&collection).WithShard(&shard), nil)
+		require.Nil(t, err)
+		require.Len(t, res.Payload, 0)
+	})
+
+	t.Run("list non-existing replication operations with valid collection and non-existing shard", func(t *testing.T) {
+		collection := paragraphClass.Class
+		shard := "non-existing"
+		res, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams().WithCollection(&collection).WithShard(&shard), nil)
+		require.Nil(t, err)
+		require.Len(t, res.Payload, 0)
+	})
+
+	t.Run("list non-existing replication operations by target node", func(t *testing.T) {
+		nodeID := "non-existing"
+		res, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams().WithTargetNode(&nodeID), nil)
+		require.Nil(t, err)
+		require.Len(t, res.Payload, 0)
+	})
+
+	t.Run("cancel replication operation", func(t *testing.T) {
+		cancelled, err := helper.Client(t).Replication.CancelReplication(replication.NewCancelReplicationParams().WithID(id), nil)
+		require.Nil(t, err)
+		require.NotNil(t, cancelled)
+	})
+
+	t.Run("wait for replication operation to be cancelled", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			details, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+			require.Nil(t, err)
+			assert.Equal(ct, string(api.CANCELLED), details.Payload.Status.State)
+		}, 30*time.Second, 1*time.Second, "replication operation should be cancelled")
+	})
+
+	t.Run("assert that async replication is not running in any of the nodes", func(t *testing.T) {
+		nodes, err := helper.Client(t).Nodes.
+			NodesGetClass(nodes.NewNodesGetClassParams().WithClassName(paragraphClass.Class), nil)
+		require.Nil(t, err)
+		for _, node := range nodes.Payload.Nodes {
+			for _, shard := range node.Shards {
+				require.Len(t, shard.AsyncReplicationStatus, 0)
+			}
+		}
+	})
+
+	t.Run("delete replication operation", func(t *testing.T) {
+		deleted, err := helper.Client(t).Replication.DeleteReplication(replication.NewDeleteReplicationParams().WithID(id), nil)
+		require.Nil(t, err)
+		require.NotNil(t, deleted)
+	})
+
+	t.Run("wait for replication operation to be deleted", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			_, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+			require.NotNil(ct, err)
+			assert.IsType(ct, replication.NewReplicationDetailsNotFound(), err)
+		}, 30*time.Second, 1*time.Second, "replication operation should be deleted")
+	})
+
+	t.Run("create one op and immediately delete all replication ops", func(t *testing.T) {
+		created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(getRequest(t, paragraphClass.Class)), nil)
+		require.Nil(t, err)
+		require.NotNil(t, created)
+		require.NotNil(t, created.Payload)
+		require.NotNil(t, created.Payload.ID)
+		id = *created.Payload.ID
+
+		deleted, err := helper.Client(t).Replication.DeleteAllReplications(replication.NewDeleteAllReplicationsParams(), nil)
+		require.Nil(t, err)
+		require.NotNil(t, deleted)
+	})
+
+	t.Run("wait for second replication operation to be deleted", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			_, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+			require.NotNil(ct, err)
+			assert.IsType(ct, replication.NewReplicationDetailsNotFound(), err)
+		}, 30*time.Second, 1*time.Second, "replication operation should be deleted")
+	})
+
+	t.Run("assert that there are no replication operations", func(t *testing.T) {
+		details, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams(), nil)
+		require.Nil(t, err)
+		require.NotNil(t, details)
+		require.NotNil(t, details.Payload)
+		require.Len(t, details.Payload, 0)
+	})
+
+	t.Run("assert that async replication is not running in any of the nodes", func(t *testing.T) {
+		nodes, err := helper.Client(t).Nodes.
+			NodesGetClass(nodes.NewNodesGetClassParams().WithClassName(paragraphClass.Class), nil)
+		require.Nil(t, err)
+		for _, node := range nodes.Payload.Nodes {
+			for _, shard := range node.Shards {
+				require.Len(t, shard.AsyncReplicationStatus, 0)
+			}
+		}
+	})
+}
+
+func getRequest(t *testing.T, className string) *models.ReplicationReplicateReplicaRequest {
+	verbose := verbosity.OutputVerbose
+	nodes, err := helper.Client(t).Nodes.NodesGetClass(nodes.NewNodesGetClassParams().WithOutput(&verbose).WithClassName(className), nil)
+	require.Nil(t, err)
+	return &models.ReplicationReplicateReplicaRequest{
+		Collection: &className,
+		SourceNode: &nodes.Payload.Nodes[0].Name,
+		TargetNode: &nodes.Payload.Nodes[1].Name,
+		Shard:      &nodes.Payload.Nodes[0].Shards[0].Name,
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/force_delete_ops_test.go

@@ -0,0 +1,132 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationForceDeleteOperations() {
+	t := suite.T()
+
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+
+	paragraphClass := articles.ParagraphsClass()
+	// Create the class
+	helper.DeleteClass(t, paragraphClass.Class)
+	helper.CreateClass(t, paragraphClass)
+
+	// Load data
+	batch := make([]*models.Object, 10000)
+	for i := 0; i < 10000; i++ {
+		batch[i] = articles.NewParagraph().
+			WithContents(fmt.Sprintf("paragraph#%d", i)).
+			Object()
+	}
+	helper.CreateObjectsBatch(t, batch)
+
+	howManyNodes := 3
+	shardsPerNode := make(map[string]string, howManyNodes)
+
+	t.Run("start replication operations", func(t *testing.T) {
+		verbose := verbosity.OutputVerbose
+		nodes, err := helper.Client(t).Nodes.NodesGetClass(nodes.NewNodesGetClassParams().WithClassName(paragraphClass.Class).WithOutput(&verbose), nil)
+		require.Nil(t, err)
+		require.Len(t, nodes.Payload.Nodes, 3)
+		for i, src := range nodes.Payload.Nodes {
+			for j, tgt := range nodes.Payload.Nodes {
+				if i != (j+1)%howManyNodes {
+					continue
+				}
+				shard := src.Shards[0]
+				shardsPerNode[src.Name] = shard.Name
+				_, err := helper.Client(t).Replication.Replicate(
+					replication.NewReplicateParams().WithBody(&models.ReplicationReplicateReplicaRequest{
+						SourceNode: &src.Name,
+						TargetNode: &tgt.Name,
+						Shard:      &shard.Name,
+						Collection: &paragraphClass.Class,
+					}),
+					nil,
+				)
+				require.Nil(t, err, "failed to start replication from %s to %s", src.Name, tgt.Name)
+			}
+		}
+	})
+
+	t.Run(fmt.Sprintf("assert that %d operations were started", howManyNodes), func(t *testing.T) {
+		resp, err := helper.Client(t).Replication.ListReplication(
+			replication.NewListReplicationParams(),
+			nil,
+		)
+		require.Nil(t, err, "failed to list replication details")
+		require.Len(t, resp.Payload, howManyNodes, "there should be %d replication operations started", howManyNodes)
+	})
+
+	t.Run("force delete all operations with dryRun=true", func(t *testing.T) {
+		dryRun := true
+		resp, err := helper.Client(t).Replication.ForceDeleteReplications(
+			replication.NewForceDeleteReplicationsParams().WithBody(&models.ReplicationReplicateForceDeleteRequest{
+				DryRun: &dryRun,
+			}),
+			nil,
+		)
+		require.Nil(t, err, "failed to force delete all replication operations")
+		// calling forceDelete with dryRun=true should return the UUIDs of the operations that would be deleted
+		require.Len(t, resp.Payload.Deleted, howManyNodes, "there should be %d replication operations to be deleted", howManyNodes)
+		require.Equal(t, resp.Payload.DryRun, true, "dry run should be false, we are not in dry run mode")
+	})
+
+	t.Run("force delete all operations dryRun=false", func(t *testing.T) {
+		resp, err := helper.Client(t).Replication.ForceDeleteReplications(
+			replication.NewForceDeleteReplicationsParams(),
+			nil,
+		)
+		require.Nil(t, err, "failed to force delete all replication operations")
+		// calling forceDelete with dryRun=false cannot return the UUIDs of the operations that were deleted so we expect an empty slice
+		require.Len(t, resp.Payload.Deleted, 0, "there should be %d replication operations deleted", 0)
+		require.Equal(t, resp.Payload.DryRun, false, "dry run should be false, we are not in dry run mode")
+	})
+
+	t.Run("assert that there are no replication operations left", func(t *testing.T) {
+		resp, err := helper.Client(t).Replication.ListReplication(
+			replication.NewListReplicationParams(),
+			nil,
+		)
+		require.Nil(t, err, "failed to list replication details")
+		require.Len(t, resp.Payload, 0, "there should be no replication operations left after force delete")
+	})
+
+	t.Run("assert that the sharding state is still intact", func(t *testing.T) {
+		verbose := verbosity.OutputVerbose
+		resp, err := helper.Client(t).Nodes.NodesGetClass(
+			nodes.NewNodesGetClassParams().WithClassName(paragraphClass.Class).WithOutput(&verbose),
+			nil,
+		)
+		require.Nil(t, err, "failed to get nodes for class %s", paragraphClass.Class)
+		require.Len(t, resp.Payload.Nodes, howManyNodes, "there should be %d nodes for class %s", howManyNodes, paragraphClass.Class)
+
+		for _, node := range resp.Payload.Nodes {
+			require.Len(t, node.Shards, 1, "each node should have exactly one shard")
+			require.Equal(t, shardsPerNode[node.Name], node.Shards[0].Name, "shard name should match the one we started with")
+		}
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/lazy_shards_test.go

@@ -0,0 +1,169 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateWithLazyShardLoading() {
+	t := suite.T()
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+
+	cls := articles.ParagraphsClass()
+	cls.MultiTenancyConfig = &models.MultiTenancyConfig{
+		Enabled:              true,
+		AutoTenantActivation: true,
+		AutoTenantCreation:   true,
+	}
+
+	// Create the class
+	t.Log("Creating class", cls.Class)
+	helper.DeleteClass(t, cls.Class)
+	helper.CreateClass(t, cls)
+
+	// Load data
+	t.Log("Loading data...")
+	tenantNames := make([]string, 0, 100)
+	for i := 0; i < 100; i++ {
+		t.Logf("into tenant %d", i)
+		tenantName := fmt.Sprintf("tenant-%d", i)
+		tenantNames = append(tenantNames, tenantName)
+		batch := make([]*models.Object, 1000)
+		for j := 0; j < 1000; j++ {
+			batch[j] = (*models.Object)(articles.NewParagraph().
+				WithContents(fmt.Sprintf("paragraph#%d", j)).
+				WithTenant(tenantName).
+				Object())
+		}
+		helper.CreateObjectsBatch(t, batch)
+	}
+
+	// Get a random subset of tenants to replicate
+	t.Log("Selecting random tenants for replication")
+	randomTenants := random(tenantNames, len(tenantNames)/4)
+
+	// Find the nodes on which the tenants are located
+	t.Log("Finding nodes for tenants")
+	verbose := verbosity.OutputVerbose
+	nodes, err := helper.Client(t).Nodes.NodesGetClass(
+		nodes.NewNodesGetClassParams().WithClassName(cls.Class).WithOutput(&verbose),
+		nil,
+	)
+	require.Nil(t, err)
+
+	replicaByTenant := make(map[string]string, len(randomTenants))
+	nodeNames := make([]string, 0, len(nodes.Payload.Nodes))
+	for _, node := range nodes.Payload.Nodes {
+		nodeNames = append(nodeNames, node.Name)
+		for _, shard := range node.Shards {
+			for _, tenantName := range randomTenants {
+				if shard.Name == tenantName {
+					replicaByTenant[tenantName] = node.Name
+				}
+			}
+		}
+	}
+
+	// Deactivate all the tenants
+	t.Log("Deactivating all tenants")
+	tenants := make([]*models.Tenant, 0, 1000)
+	for _, tenantName := range tenantNames {
+		tenants = append(tenants, &models.Tenant{Name: tenantName, ActivityStatus: models.TenantActivityStatusINACTIVE})
+	}
+	helper.UpdateTenants(t, cls.Class, tenants)
+
+	opIds := make([]strfmt.UUID, 0, len(replicaByTenant))
+	for tenantName, sourceNode := range replicaByTenant {
+		t.Run(fmt.Sprintf("replicate tenant %s on node %s", tenantName, sourceNode), func(t *testing.T) {
+			// Choose random node as the target node
+			var targetNode string
+			rand.Shuffle(len(nodeNames), func(i, j int) {
+				nodeNames[i], nodeNames[j] = nodeNames[j], nodeNames[i]
+			})
+			for _, tgtNode := range nodeNames {
+				if sourceNode != tgtNode {
+					targetNode = tgtNode
+					t.Logf("Selected target node %s for tenant %s", targetNode, tenantName)
+					break
+				}
+			}
+
+			// Start replication
+			t.Logf("Starting replication for tenant %s from node %s to target node %s", tenantName, sourceNode, targetNode)
+			move := "MOVE"
+			res, err := helper.Client(t).Replication.Replicate(
+				replication.NewReplicateParams().WithBody(&models.ReplicationReplicateReplicaRequest{
+					SourceNode: &sourceNode,
+					TargetNode: &targetNode,
+					Collection: &cls.Class,
+					Shard:      &tenantName,
+					Type:       &move,
+				}),
+				nil,
+			)
+			require.Nil(t, err, "failed to start replication for tenant %s on node %s", tenantName, sourceNode)
+			opIds = append(opIds, *res.Payload.ID)
+		})
+	}
+
+	// Wait for all replication operations to complete
+	t.Log("Waiting for replication operations to complete")
+	assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+		completed := make(map[strfmt.UUID]bool, len(opIds))
+		for _, opId := range opIds {
+			res, err := helper.Client(t).Replication.ReplicationDetails(
+				replication.NewReplicationDetailsParams().WithID(opId),
+				nil,
+			)
+			require.Nil(t, err, "failed to get replication operation %s", opId)
+			if res.Payload.Status.State == models.ReplicationReplicateDetailsReplicaStatusStateREADY {
+				completed[opId] = true
+			} else {
+				completed[opId] = false
+			}
+		}
+		howManyDone := 0
+		for _, done := range completed {
+			if done {
+				howManyDone++
+			}
+		}
+		t.Log("Replication operations completed:", howManyDone, "of", len(completed))
+		assert.True(ct, howManyDone == len(completed), "not all replication operations completed yet")
+	}, 300*time.Second, 5*time.Second, "replication operations did not complete in time")
+}
+
+func random[T any](s []T, k int) []T {
+	if k > len(s) {
+		k = len(s)
+	}
+	indices := rand.Perm(len(s))[:k]
+	result := make([]T, k)
+	for i, idx := range indices {
+		result[i] = s[idx]
+	}
+	return result
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/move_test.go

@@ -0,0 +1,87 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateMOVEDeletesSourceReplica() {
+	t := suite.T()
+
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	helper.DeleteClass(t, paragraphClass.Class)
+	helper.CreateClass(t, paragraphClass)
+
+	// Create paragraphs
+	batch := make([]*models.Object, 10000)
+	for i := 0; i < 10000; i++ {
+		batch[i] = articles.NewParagraph().
+			WithContents(fmt.Sprintf("paragraph#%d", i)).
+			Object()
+	}
+	helper.CreateObjectsBatch(t, batch)
+
+	req := getRequest(t, paragraphClass.Class)
+
+	move := "MOVE"
+	req.Type = &move
+	// Create MOVE replication operation and wait until the shard is in the sharding state (meaning it is uncancellable)
+	created, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(req), nil)
+	require.Nil(t, err)
+	id := *created.Payload.ID
+
+	// Wait until the replication operation is READY
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		status, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+		require.Nil(t, err)
+		require.Equal(ct, "READY", status.Payload.Status.State)
+	}, 180*time.Second, 100*time.Millisecond, "Replication operation should be in READY state")
+
+	t.Run("ensure target and source replicas are there/gone respectively", func(t *testing.T) {
+		verbose := verbosity.OutputVerbose
+		nodes, err := helper.Client(t).Nodes.NodesGetClass(nodes.NewNodesGetClassParams().WithOutput(&verbose).WithClassName(paragraphClass.Class), nil)
+		require.Nil(t, err)
+		foundSrc := false
+		foundDst := false
+		for _, node := range nodes.Payload.Nodes {
+			if *req.SourceNode == node.Name {
+				for _, shard := range node.Shards {
+					if shard.Name == *req.Shard {
+						foundSrc = true
+					}
+				}
+			}
+			if *req.TargetNode == node.Name {
+				for _, shard := range node.Shards {
+					if shard.Name == *req.Shard {
+						foundDst = true
+					}
+				}
+			}
+		}
+		require.False(t, foundSrc, "source replica should not be there")
+		require.True(t, foundDst, "destination replica should be there")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/mutating_data_test.go

@@ -0,0 +1,287 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client"
+	"github.com/weaviate/weaviate/client/batch"
+	"github.com/weaviate/weaviate/client/graphql"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/objects"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateWhileMutatingDataWithNoAutomatedResolution() {
+	test(suite, models.ReplicationConfigDeletionStrategyNoAutomatedResolution)
+}
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateWhileMutatingDataWithDeleteOnConflict() {
+	test(suite, models.ReplicationConfigDeletionStrategyDeleteOnConflict)
+}
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateWhileMutatingDataWithTimeBasedResolution() {
+	test(suite, models.ReplicationConfigDeletionStrategyTimeBasedResolution)
+}
+
+func test(suite *ReplicationTestSuite, strategy string) {
+	t := suite.T()
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+
+	cls := articles.ParagraphsClass()
+	cls.MultiTenancyConfig = &models.MultiTenancyConfig{
+		Enabled:              true,
+		AutoTenantActivation: true,
+		AutoTenantCreation:   true,
+	}
+
+	cls.ReplicationConfig = &models.ReplicationConfig{
+		Factor:           int64(2),
+		DeletionStrategy: strategy,
+	}
+
+	// Create the class
+	t.Log("Creating class", cls.Class)
+	helper.DeleteClass(t, cls.Class)
+	helper.CreateClass(t, cls)
+
+	// Wait for all replication ops to be deleted
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		res, err := helper.Client(t).Replication.ListReplication(
+			replication.NewListReplicationParams().WithCollection(&cls.Class),
+			nil,
+		)
+		require.Nil(ct, err, "failed to list replication operations for class %s", cls.Class)
+		assert.Empty(ct, res.Payload, "there are still replication operations for class %s", cls.Class)
+	}, 30*time.Second, 5*time.Second, "replication operations for class %s did not finish in time", cls.Class)
+
+	// Load data
+	t.Log("Loading data into tenant")
+	tenantName := "tenant"
+	batch := make([]*models.Object, 1000)
+	for j := 0; j < 1000; j++ {
+		batch[j] = (*models.Object)(articles.NewParagraph().
+			WithContents(fmt.Sprintf("paragraph#%d", j)).
+			WithTenant(tenantName).
+			Object())
+	}
+	helper.CreateObjectsBatch(t, batch)
+
+	// Find the nodes on which the tenants are located
+	t.Log("Finding nodes and tenant replicas")
+	ns, err := helper.Client(t).Nodes.NodesGetClass(
+		nodes.NewNodesGetClassParams().WithClassName(cls.Class),
+		nil,
+	)
+	require.Nil(t, err)
+	nodeNames := make([]string, 0, len(ns.Payload.Nodes))
+	for _, node := range ns.Payload.Nodes {
+		nodeNames = append(nodeNames, node.Name)
+	}
+
+	shardingState, err := helper.Client(t).Replication.GetCollectionShardingState(
+		replication.NewGetCollectionShardingStateParams().WithCollection(&cls.Class),
+		nil,
+	)
+	require.Nil(t, err)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	t.Log("Starting data mutation in background")
+	go mutateData(t, ctx, helper.Client(t), cls.Class, tenantName, 100)
+
+	// Choose other node node as the target node
+	var targetNode string
+	var sourceNode string
+	for _, shard := range shardingState.Payload.ShardingState.Shards {
+		if shard.Shard != tenantName {
+			continue
+		}
+		sourceNode = shard.Replicas[0]                                 // Take the first (of two) replica as the source node
+		targetNode = symmetricDifference(nodeNames, shard.Replicas)[0] // Choose the other node as the target
+	}
+
+	// Start replication
+	t.Logf("Starting replication for tenant %s from node %s to target node %s", tenantName, sourceNode, targetNode)
+	move := "MOVE"
+	res, err := helper.Client(t).Replication.Replicate(
+		replication.NewReplicateParams().WithBody(&models.ReplicationReplicateReplicaRequest{
+			SourceNode: &sourceNode,
+			TargetNode: &targetNode,
+			Collection: &cls.Class,
+			Shard:      &tenantName,
+			Type:       &move,
+		}),
+		nil,
+	)
+	require.Nil(t, err, "failed to start replication for tenant %s from node %s to node %s", tenantName, sourceNode, targetNode)
+	opId := *res.Payload.ID
+
+	t.Log("Waiting for replication operation to complete")
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		res, err := helper.Client(t).Replication.ReplicationDetails(
+			replication.NewReplicationDetailsParams().WithID(opId),
+			nil,
+		)
+		require.Nil(t, err, "failed to get replication operation %s", opId)
+		assert.True(ct, res.Payload.Status.State == models.ReplicationReplicateDetailsReplicaStatusStateREADY, "replication operation not completed yet")
+	}, 300*time.Second, 5*time.Second, "replication operations did not complete in time")
+
+	t.Log("Replication operation completed successfully, cancelling data mutation")
+	cancel() // stop mutating to allow the verification to proceed
+
+	t.Log("Waiting for a while to ensure all data is replicated")
+
+	// Verify that shards all have consistent data
+	t.Log("Verifying data consistency of tenant")
+
+	t.Log("Replication operation completed successfully, cancelling data mutation")
+	cancel() // stop mutating to allow the verification to proceed
+
+	t.Log("Waiting for replicas to converge on object count")
+
+	verbose := verbosity.OutputVerbose
+	ns, err = helper.Client(t).Nodes.NodesGetClass(
+		nodes.NewNodesGetClassParams().WithClassName(cls.Class).WithOutput(&verbose),
+		nil,
+	)
+	require.Nil(t, err)
+
+	nodeToAddress := map[string]string{}
+	for idx, node := range ns.Payload.Nodes {
+		nodeToAddress[node.Name] = suite.compose.GetWeaviateNode(idx + 1).URI()
+	}
+
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		consistent := true
+		var expected int64 = -1
+
+		for node, address := range nodeToAddress {
+			helper.SetupClient(address)
+			res, err := helper.Client(t).Graphql.GraphqlPost(graphql.NewGraphqlPostParams().WithBody(&models.GraphQLQuery{
+				Query: fmt.Sprintf(`{ Aggregate { %s(tenant: "%s") { meta { count } } } }`, cls.Class, tenantName),
+			}), nil)
+			require.Nil(ct, err, "failed to get object count for tenant %s on node %s", tenantName, node)
+			val, err := res.Payload.Data["Aggregate"].(map[string]any)["Paragraph"].([]any)[0].(map[string]any)["meta"].(map[string]any)["count"].(json.Number).Int64()
+			require.Nil(ct, err, "failed to parse object count for tenant %s on node %s", tenantName, node)
+			if expected == -1 {
+				expected = val
+			}
+			if val != expected {
+				consistent = false
+			}
+		}
+
+		require.True(ct, consistent, "replicas did not converge on object count")
+	}, 2*time.Minute, 5*time.Second, "replication operations for class %s did not converge in time", cls.Class)
+}
+
+func mutateData(t *testing.T, ctx context.Context, client *client.Weaviate, className string, tenantName string, wait int) {
+	for {
+		select {
+		case <-ctx.Done():
+			t.Log("Mutation context done, stopping data mutation")
+			return
+		default:
+			// Add some new objects
+			randAdd := rand.Intn(20) + 1
+			btch := make([]*models.Object, randAdd)
+			for i := 0; i < randAdd; i++ {
+				btch[i] = (*models.Object)(articles.NewParagraph().
+					WithContents(fmt.Sprintf("new-paragraph#%d", i)).
+					WithTenant(tenantName).
+					Object())
+			}
+			all := "ALL"
+			params := batch.NewBatchObjectsCreateParams().
+				WithBody(batch.BatchObjectsCreateBody{
+					Objects: btch,
+				}).WithConsistencyLevel(&all)
+			client.Batch.BatchObjectsCreate(params, nil)
+
+			time.Sleep(time.Duration(wait) * time.Millisecond) // Sleep to simulate some delay between mutations
+
+			// Get the existing objects
+			limit := int64(10000)
+			res, err := client.Objects.ObjectsList(
+				objects.NewObjectsListParams().WithClass(&className).WithTenant(&tenantName).WithLimit(&limit),
+				nil,
+			)
+			if err != nil {
+				t.Logf("Error listing objects for tenant %s: %v", tenantName, err)
+				continue
+			}
+			randUpdate := rand.Intn(20) + 1
+			toUpdate := random(res.Payload.Objects, randUpdate)
+			randDelete := rand.Intn(20) + 1
+			toDelete := random(symmetricDifference(res.Payload.Objects, toUpdate), randDelete)
+
+			time.Sleep(time.Duration(wait) * time.Millisecond) // Sleep to simulate some delay between mutations
+
+			// Update some existing objects
+			for _, obj := range toUpdate {
+				updated := (*models.Object)(articles.NewParagraph().
+					WithContents(fmt.Sprintf("updated-%s", obj.Properties.(map[string]any)["contents"])).
+					WithTenant(tenantName).
+					WithID(obj.ID).
+					Object())
+				client.Objects.ObjectsClassPut(
+					objects.NewObjectsClassPutParams().WithID(obj.ID).WithBody(updated).WithConsistencyLevel(&all),
+					nil,
+				)
+			}
+
+			time.Sleep(time.Duration(wait) * time.Millisecond) // Sleep to simulate some delay between mutations
+
+			// Delete some existing objects
+			for _, obj := range toDelete {
+				client.Objects.ObjectsClassDelete(
+					objects.NewObjectsClassDeleteParams().WithClassName(className).WithID(obj.ID).WithTenant(&tenantName).WithConsistencyLevel(&all),
+					nil,
+				)
+			}
+		}
+	}
+}
+
+// symmetricDifference returns the symmetric difference of two slices.
+// It returns a slice containing elements that are in either a or b, but not in both
+func symmetricDifference[T comparable](a, b []T) []T {
+	count := make(map[T]int)
+
+	for _, v := range a {
+		count[v]++
+	}
+	for _, v := range b {
+		count[v]++
+	}
+
+	var result []T
+	for k, v := range count {
+		if v == 1 {
+			result = append(result, k)
+		}
+	}
+	return result
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/not_implemented_test.go

@@ -0,0 +1,114 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+const UUID = strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168242")
+
+type ReplicationNotImplementedTestSuite struct {
+	suite.Suite
+	compose *docker.DockerCompose
+	down    func()
+}
+
+func (suite *ReplicationNotImplementedTestSuite) SetupSuite() {
+	t := suite.T()
+	t.Setenv("TEST_WEAVIATE_IMAGE", "weaviate/test-server")
+
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithWeaviateEnv("REPLICA_MOVEMENT_MINIMUM_ASYNC_WAIT", "5s").
+		WithWeaviateEnv("REPLICA_MOVEMENT_DISABLED", "true").
+		Start(mainCtx)
+	require.Nil(t, err)
+	suite.compose = compose
+	suite.down = func() {
+		if err := compose.Terminate(mainCtx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}
+}
+
+func (suite *ReplicationNotImplementedTestSuite) TearDownSuite() {
+	if suite.down != nil {
+		suite.down()
+	}
+}
+
+func TestReplicationNotImplementedTestSuite(t *testing.T) {
+	suite.Run(t, new(ReplicationNotImplementedTestSuite))
+}
+
+func (suite *ReplicationNotImplementedTestSuite) TestReplicationNotImplemented() {
+	t := suite.T()
+
+	helper.SetupClient(suite.compose.GetWeaviate().URI())
+
+	t.Run("POST /replication/replicate", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.Replicate(replication.NewReplicateParams().WithBody(&models.ReplicationReplicateReplicaRequest{
+			Collection: string_("test-collection"),
+			TargetNode: string_("tgt-node"),
+			Shard:      string_("test-shard"),
+			SourceNode: string_("src-node"),
+		}), nil)
+		require.IsType(t, &replication.ReplicateNotImplemented{}, err, fmt.Sprintf("Expected NotImplemented error for replicate but got %v", err))
+	})
+
+	t.Run("DELETE /replication/replicate", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.DeleteAllReplications(replication.NewDeleteAllReplicationsParams(), nil)
+		require.IsType(t, &replication.DeleteAllReplicationsNotImplemented{}, err, fmt.Sprintf("Expected NotImplemented error for delete all replications but got %v", err))
+	})
+
+	t.Run("GET /replication/replicate/{id}", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(UUID), nil)
+		require.IsType(t, &replication.ReplicationDetailsNotImplemented{}, err, fmt.Sprintf("Expected NotImplemented error for replication details but got %v", err))
+	})
+
+	t.Run("DELETE /replication/replicate/{id}", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.DeleteReplication(replication.NewDeleteReplicationParams().WithID(UUID), nil)
+		require.IsType(t, &replication.DeleteReplicationNotImplemented{}, err, fmt.Sprintf("Expected NotImplemented error for delete replication but got %v", err))
+	})
+
+	t.Run("GET /replication/replicate/list", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.ListReplication(replication.NewListReplicationParams(), nil)
+		require.IsType(t, &replication.ListReplicationNotImplemented{}, err, fmt.Sprintf("Expected NotImplemented error for list replication but got %v", err))
+	})
+
+	t.Run("POST /replication/replicate/{id}/cancel", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.CancelReplication(replication.NewCancelReplicationParams().WithID(UUID), nil)
+		require.IsType(t, &replication.CancelReplicationNotImplemented{}, err, fmt.Sprintf("Expected NotImplemented error for cancel replication but got %v", err))
+	})
+
+	t.Run("GET /replication/sharding-state", func(t *testing.T) {
+		_, err := helper.Client(t).Replication.GetCollectionShardingState(replication.NewGetCollectionShardingStateParams(), nil)
+		require.IsType(t, &replication.GetCollectionShardingStateNotImplemented{}, err, fmt.Sprintf("Expected NotImplemented error for get collection sharding state but got %v", err))
+	})
+}
+
+func string_(s string) *string {
+	return &s
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/replica_replication/fast/replica_replication_test.go

@@ -0,0 +1,702 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/weaviate/weaviate/cluster/proto/api"
+
+	"github.com/go-openapi/strfmt"
+	"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"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"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"
+)
+
+var paragraphIDs = []strfmt.UUID{
+	strfmt.UUID("3bf331ac-8c86-4f95-b127-2f8f96bbc093"),
+	strfmt.UUID("47b26ba1-6bc9-41f8-a655-8b9a5b60e1a3"),
+	strfmt.UUID("5fef6289-28d2-4ea2-82a9-48eb501200cd"),
+	strfmt.UUID("34a673b4-8859-4cb4-bb30-27f5622b47e9"),
+	strfmt.UUID("9fa362f5-c2dc-4fb8-b5b2-11701adc5f75"),
+	strfmt.UUID("63735238-6723-4caf-9eaa-113120968ff4"),
+	strfmt.UUID("2236744d-b2d2-40e5-95d8-2574f20a7126"),
+	strfmt.UUID("1a54e25d-aaf9-48d2-bc3c-bef00b556297"),
+	strfmt.UUID("0b8a0e70-a240-44b2-ac6d-26dda97523b9"),
+	strfmt.UUID("50566856-5d0a-4fb1-a390-e099bc236f66"),
+}
+
+type ReplicationHappyPathTestSuite struct {
+	suite.Suite
+}
+
+func (suite *ReplicationHappyPathTestSuite) SetupSuite() {
+	t := suite.T()
+	t.Setenv("TEST_WEAVIATE_IMAGE", "weaviate/test-server")
+}
+
+func TestReplicationHappyPathTestSuite(t *testing.T) {
+	suite.Run(t, new(ReplicationHappyPathTestSuite))
+}
+
+func (suite *ReplicationHappyPathTestSuite) TestReplicaMovementHappyPath() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithText2VecContextionary().
+		WithWeaviateEnv("REPLICA_MOVEMENT_MINIMUM_ASYNC_WAIT", "5s").
+		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, 20*time.Minute)
+	defer cancel()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	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)
+		articleClass.ShardingConfig = map[string]interface{}{"desiredCount": 1}
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       1,
+			AsyncEnabled: false,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	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())
+
+	t.Run("insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviate().URI(), batch)
+	})
+
+	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 uuid strfmt.UUID
+	sourceNode := -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
+			}
+
+			replicationType := api.COPY.String()
+			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
+				resp, err := helper.Client(t).Replication.Replicate(
+					replication.NewReplicateParams().WithBody(
+						&models.ReplicationReplicateReplicaRequest{
+							Collection: &paragraphClass.Class,
+							SourceNode: &node.Name,
+							TargetNode: &targetNode,
+							Shard:      &shard.Name,
+							Type:       &replicationType,
+						},
+					),
+					nil,
+				)
+				require.NoError(t, err)
+				require.Equal(t, http.StatusOK, resp.Code(), "replication replicate operation didn't return 200 OK")
+				require.NotNil(t, resp.Payload)
+				require.NotNil(t, resp.Payload.ID)
+				require.NotEmpty(t, *resp.Payload.ID)
+				uuid = *resp.Payload.ID
+			}
+		}
+		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(uuid), 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", uuid)
+	})
+
+	// 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 data is available for paragraph on node3 with consistency level one", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			for _, objId := range paragraphIDs {
+				exists, err := common.ObjectExistsCL(t, compose.ContainerURI(3), paragraphClass.Class, objId, types.ConsistencyLevelOne)
+				assert.Nil(ct, err)
+				assert.True(ct, exists)
+
+				resp, err := common.GetObjectCL(t, compose.ContainerURI(3), paragraphClass.Class, objId, types.ConsistencyLevelOne)
+				assert.Nil(ct, err)
+				assert.NotNil(ct, resp)
+			}
+		}, 10*time.Second, 1*time.Second, "node3 doesn't have paragraph data")
+	})
+
+	t.Run("assert that async replication is not running in any of the nodes", func(t *testing.T) {
+		nodes, err := helper.Client(t).Nodes.
+			NodesGetClass(nodes.NewNodesGetClassParams().WithClassName(paragraphClass.Class), nil)
+		require.Nil(t, err)
+		for _, node := range nodes.Payload.Nodes {
+			for _, shard := range node.Shards {
+				require.Len(t, shard.AsyncReplicationStatus, 0)
+			}
+		}
+	})
+}
+
+func (suite *ReplicationHappyPathTestSuite) TestReplicaMovementTenantHappyPath() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithText2VecContextionary().
+		WithWeaviateEnv("REPLICA_MOVEMENT_MINIMUM_ASYNC_WAIT", "5s").
+		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, 20*time.Minute)
+	defer cancel()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       1,
+			AsyncEnabled: false,
+		}
+		paragraphClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+			Enabled:              true,
+			AutoTenantActivation: true,
+			AutoTenantCreation:   true,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       1,
+			AsyncEnabled: false,
+		}
+		articleClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+			Enabled:              true,
+			AutoTenantActivation: true,
+			AutoTenantCreation:   true,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	t.Run("insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				WithTenant("tenant0").
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviate().URI(), batch)
+	})
+
+	// any node can be chosen as the tenant source node (even if that node is down at the time of creation)
+	// so we dynamically find the source and target nodes
+	sourceNode := -1
+	var targetNode string
+	var targetNodeURI string
+	var uuid strfmt.UUID
+	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)
+
+		hasFoundNode := false
+		hasFoundShard := false
+
+		for i, node := range body.Payload.Nodes {
+			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 another node for shard %s", node.Name, shard.Name)
+				// i + 1 because stop/start routine are 1 based not 0
+				sourceNode = i + 1
+				break
+			}
+
+			if hasFoundShard {
+				break
+			}
+		}
+
+		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")
+
+		// Choose a target node that is not the source node
+		for i, node := range body.Payload.Nodes {
+			if i+1 == sourceNode {
+				continue
+			}
+			targetNode = node.Name
+			targetNodeURI = compose.ContainerURI(i + 1)
+			break
+		}
+
+		require.NotEmpty(t, targetNode, "could not find a target node different from the source node")
+
+		for _, node := range body.Payload.Nodes {
+			if node.Name == targetNode {
+				continue
+			}
+
+			for _, shard := range node.Shards {
+				if shard.Class != paragraphClass.Class {
+					continue
+				}
+
+				t.Logf("Starting replica replication from %s to %s for shard %s", node.Name, targetNode, shard.Name)
+				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")
+				require.NotNil(t, resp.Payload)
+				require.NotNil(t, resp.Payload.ID)
+				require.NotEmpty(t, *resp.Payload.ID)
+				uuid = *resp.Payload.ID
+			}
+		}
+	})
+
+	// If didn't find needed info fail now
+	if sourceNode == -1 || targetNode == "" || targetNodeURI == "" || uuid.String() == "" {
+		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(uuid), 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")
+		}, 240*time.Second, 1*time.Second, "replication operation %s not finished in time", uuid)
+	})
+
+	// 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 data is available for paragraph on node3 with consistency level one", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			for _, objId := range paragraphIDs {
+				obj, err := common.GetTenantObjectFromNode(t, targetNodeURI, paragraphClass.Class, objId, targetNode, "tenant0")
+				assert.Nil(ct, err)
+				assert.NotNil(ct, obj)
+			}
+		}, 10*time.Second, 1*time.Second, "node3 doesn't have paragraph data")
+	})
+
+	t.Run("assert that async replication is not running in any of the nodes", func(t *testing.T) {
+		nodes, err := helper.Client(t).Nodes.
+			NodesGetClass(nodes.NewNodesGetClassParams().WithClassName(paragraphClass.Class), nil)
+		require.Nil(t, err)
+		for _, node := range nodes.Payload.Nodes {
+			for _, shard := range node.Shards {
+				require.Len(t, shard.AsyncReplicationStatus, 0)
+			}
+		}
+	})
+}
+
+// TODO fix flake and uncomment
+// func (suite *ReplicationTestSuite) TestReplicaMovementTenantParallelWrites() {
+// 	t := suite.T()
+// 	mainCtx := context.Background()
+// 	logger, _ := logrustest.NewNullLogger()
+
+// 	clusterSize := 3
+// 	compose, err := docker.New().
+// 		WithWeaviateCluster(clusterSize).
+// 		WithText2VecContextionary().
+// 		WithWeaviateEnv("REPLICA_MOVEMENT_MINIMUM_ASYNC_WAIT", "10s").
+// 		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())
+// 		}
+// 	}()
+
+// 	_, cancel := context.WithTimeout(mainCtx, 5*time.Minute)
+// 	defer cancel()
+
+// 	helper.SetupClient(compose.GetWeaviate().URI())
+// 	paragraphClass := articles.ParagraphsClass()
+// 	articleClass := articles.ArticlesClass()
+
+// 	t.Run("create schema", func(t *testing.T) {
+// 		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+// 			Factor:       2,
+// 			AsyncEnabled: false,
+// 		}
+// 		paragraphClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+// 			Enabled:              true,
+// 			AutoTenantActivation: true,
+// 			AutoTenantCreation:   true,
+// 		}
+// 		paragraphClass.Vectorizer = "text2vec-contextionary"
+// 		helper.CreateClass(t, paragraphClass)
+// 		articleClass.ReplicationConfig = &models.ReplicationConfig{
+// 			Factor:       2,
+// 			AsyncEnabled: false,
+// 		}
+// 		articleClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+// 			Enabled:              true,
+// 			AutoTenantActivation: true,
+// 			AutoTenantCreation:   true,
+// 		}
+// 		helper.CreateClass(t, articleClass)
+// 	})
+
+// 	t.Run("insert initial paragraphs", func(t *testing.T) {
+// 		batch := make([]*models.Object, len(paragraphIDs))
+// 		for i, id := range paragraphIDs {
+// 			batch[i] = articles.NewParagraph().
+// 				WithID(id).
+// 				WithContents(fmt.Sprintf("paragraph#%d", i)).
+// 				WithTenant("tenant0").
+// 				Object()
+// 		}
+// 		common.CreateObjects(t, compose.GetWeaviate().URI(), batch)
+// 	})
+
+// 	parallelWriteWg := sync.WaitGroup{}
+// 	parallelWriteIDs := []string{}
+// 	replicationDone := make(chan struct{})
+// 	t.Run("start parallel writes", func(t *testing.T) {
+// 		parallelWriteWg.Add(1)
+// 		enterrors.GoWrapper(func() {
+// 			defer parallelWriteWg.Done()
+// 			containerId := 1
+// 			for {
+// 				select {
+// 				case <-replicationDone:
+// 					return
+// 				default:
+// 					newWriteId := uuid.New().String()
+// 					err = createObjectThreadSafe(
+// 						compose.ContainerURI(containerId),
+// 						paragraphClass.Class,
+// 						map[string]interface{}{
+// 							"contents": fmt.Sprintf("paragraph#%d", len(paragraphIDs)+len(parallelWriteIDs)),
+// 						},
+// 						newWriteId,
+// 						"tenant0",
+// 					)
+// 					assert.NoError(t, err, "error creating object on node with id %d", containerId)
+// 					parallelWriteIDs = append(parallelWriteIDs, newWriteId)
+// 					containerId++
+// 					if containerId >= clusterSize+1 {
+// 						containerId = 1
+// 					}
+// 				}
+// 			}
+// 		}, logger)
+// 	})
+
+// 	// any node can be chosen as the tenant source node (even if that node is down at the time of creation)
+// 	// so we dynamically find the source and target nodes
+// 	var opUuid strfmt.UUID
+// 	var shardName string
+// 	type nodeInfo struct {
+// 		nodeContainerIndex int
+// 		nodeURI            string
+// 		nodeName           string
+// 	}
+// 	sourceNode := nodeInfo{}
+// 	targetNode := nodeInfo{}
+// 	replicaNode := nodeInfo{}
+// 	allNodeInfos := []nodeInfo{}
+// 	// TODO test copy as well
+// 	transferType := api.MOVE.String()
+// 	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)
+
+// 		hasFoundNode := false
+// 		hasFoundShard := false
+
+// 		// Find two source nodes that have shards
+// 		for i, node := range body.Payload.Nodes {
+// 			containerIndex := i + 1
+// 			allNodeInfos = append(allNodeInfos, nodeInfo{nodeURI: compose.ContainerURI(containerIndex), nodeName: node.Name, nodeContainerIndex: containerIndex})
+// 			if len(node.Shards) >= 1 {
+// 				hasFoundNode = true
+// 				for _, shard := range node.Shards {
+// 					if shard.Class != paragraphClass.Class {
+// 						continue
+// 					}
+// 					hasFoundShard = true
+// 					shardName = shard.Name
+// 					// i + 1 because stop/start routine are 1 based not 0
+// 					if sourceNode.nodeName == "" {
+// 						sourceNode = nodeInfo{nodeURI: compose.ContainerURI(containerIndex), nodeName: node.Name, nodeContainerIndex: containerIndex}
+// 					} else {
+// 						replicaNode = nodeInfo{nodeURI: compose.ContainerURI(containerIndex), nodeName: node.Name, nodeContainerIndex: containerIndex}
+// 					}
+// 				}
+// 			}
+// 		}
+
+// 		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")
+// 		require.NotEmpty(t, sourceNode.nodeName, "could not find two source nodes with shards for paragraph")
+// 		require.NotEmpty(t, sourceNode.nodeURI, "could not find two source nodes with shards for paragraph")
+// 		require.NotEmpty(t, replicaNode.nodeName, "could not find two source nodes with shards for paragraph")
+// 		require.NotEmpty(t, replicaNode.nodeURI, "could not find two source nodes with shards for paragraph")
+// 		require.NotEqual(t, sourceNode.nodeName, replicaNode.nodeName, "source and replica nodes are the same")
+// 		require.NotEqual(t, sourceNode.nodeURI, replicaNode.nodeURI, "source and replica nodes are the same")
+
+// 		// Choose a target node that is not one of the source nodes
+// 		for i, node := range body.Payload.Nodes {
+// 			if node.Name == sourceNode.nodeName || node.Name == replicaNode.nodeName {
+// 				continue
+// 			}
+// 			targetNode = nodeInfo{nodeURI: compose.ContainerURI(i + 1), nodeName: node.Name}
+// 			break
+// 		}
+
+// 		require.NotEmpty(t, targetNode, "could not find a target node different from the source nodes")
+
+// 		t.Logf("Starting replica replication from %s to %s for shard %s", sourceNode.nodeName, targetNode.nodeName, shardName)
+// 		resp, err := helper.Client(t).Replication.Replicate(
+// 			replication.NewReplicateParams().WithBody(
+// 				&models.ReplicationReplicateReplicaRequest{
+// 					CollectionID:        &paragraphClass.Class,
+// 					SourceNodeName:      &sourceNode.nodeName,
+// 					DestinationNodeName: &targetNode.nodeName,
+// 					ShardID:             &shardName,
+// 					TransferType:        &transferType,
+// 				},
+// 			),
+// 			nil,
+// 		)
+// 		require.NoError(t, err)
+// 		require.Equal(t, http.StatusOK, resp.Code(), "replication replicate operation didn't return 200 OK")
+// 		require.NotNil(t, resp.Payload)
+// 		require.NotNil(t, resp.Payload.ID)
+// 		require.NotEmpty(t, *resp.Payload.ID)
+// 		opUuid = *resp.Payload.ID
+// 	})
+
+// 	require.NotEmpty(t, opUuid, "opUuid is empty")
+// 	require.NotEmpty(t, sourceNode.nodeName, "sourceNode is empty")
+// 	require.NotEmpty(t, sourceNode.nodeURI, "sourceNode is empty")
+// 	require.NotEmpty(t, targetNode.nodeName, "targetNode is empty")
+// 	require.NotEmpty(t, targetNode.nodeURI, "targetNode is empty")
+// 	require.NotEmpty(t, replicaNode.nodeName, "replicaNode is empty")
+// 	require.NotEmpty(t, replicaNode.nodeURI, "replicaNode is empty")
+// 	require.NotEqual(t, sourceNode.nodeName, replicaNode.nodeName, "source and replica nodes are the same")
+// 	require.NotEqual(t, sourceNode.nodeURI, replicaNode.nodeURI, "source and replica nodes are the same")
+// 	require.NotEqual(t, targetNode.nodeName, sourceNode.nodeName, "target and source nodes are the same")
+// 	require.NotEqual(t, targetNode.nodeURI, sourceNode.nodeURI, "target and source nodes are the same")
+// 	require.NotEqual(t, targetNode.nodeName, replicaNode.nodeName, "target and replica nodes are the same")
+// 	require.NotEqual(t, targetNode.nodeURI, replicaNode.nodeURI, "target and replica nodes are the same")
+
+// 	// 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(opUuid), 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")
+// 		}, 240*time.Second, 1*time.Second, "replication operation %s not finished in time", opUuid)
+// 		// let some writes keep going for a few seconds after the op is ready
+// 		time.Sleep(5 * time.Second)
+// 		// now stop the writes
+// 		close(replicationDone)
+// 		parallelWriteWg.Wait()
+// 	})
+
+// 	t.Run("all parallel writes are available", func(t *testing.T) {
+// 		numParallelWrites := len(parallelWriteIDs)
+// 		assert.True(t, numParallelWrites > 1000, "expected at least 1000 parallel writes")
+// 		for _, nodeInfo := range allNodeInfos {
+// 			// in a move, sourceNode no longer has the shard replica, so we skip it
+// 			if transferType == api.MOVE.String() && nodeInfo.nodeName == sourceNode.nodeName {
+// 				continue
+// 			}
+
+// 			assert.Equal(t, int64(numParallelWrites+len(paragraphIDs)), common.CountTenantObjects(t, nodeInfo.nodeURI, paragraphClass.Class, "tenant0"), fmt.Sprintf("expected %d objects on node %s", numParallelWrites+len(paragraphIDs), nodeInfo.nodeName))
+// 		}
+// 		for _, nodeInfo := range allNodeInfos {
+// 			firstMissingObjectForNode := ""
+// 			numMissingObjectsForNode := 0
+// 			for _, id := range parallelWriteIDs {
+// 				// in a move, sourceNode no longer has the shard replica, so we skip it
+// 				if transferType == api.MOVE.String() && nodeInfo.nodeName == sourceNode.nodeName {
+// 					continue
+// 				}
+
+// 				obj, err := common.GetTenantObjectFromNode(t, nodeInfo.nodeURI, paragraphClass.Class, strfmt.UUID(id), nodeInfo.nodeName, "tenant0")
+// 				if err != nil || obj == nil {
+// 					numMissingObjectsForNode++
+// 					if firstMissingObjectForNode == "" {
+// 						assert.Nil(t, err, "error getting object from node %s", nodeInfo.nodeName, id, err)
+// 						assert.NotNil(t, obj, "object not found on node", nodeInfo.nodeName, id)
+// 						firstMissingObjectForNode = id
+// 					}
+// 				}
+// 			}
+// 			assert.Equal(t, 0, numMissingObjectsForNode, "expected no missing objects on node %s", nodeInfo.nodeName)
+// 			assert.Empty(t, firstMissingObjectForNode, "expected no missing objects on node %s", nodeInfo.nodeName)
+// 		}
+// 	})
+
+// 	t.Run("assert data is available for paragraph on node3 with consistency level one", func(t *testing.T) {
+// 		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+// 			for _, objId := range paragraphIDs {
+// 				obj, err := common.GetTenantObjectFromNode(t, targetNode.nodeURI, paragraphClass.Class, objId, targetNode.nodeName, "tenant0")
+// 				assert.Nil(ct, err)
+// 				assert.NotNil(ct, obj)
+// 			}
+// 		}, 10*time.Second, 1*time.Second, "node3 doesn't have paragraph data")
+// 	})
+// }

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

@@ -0,0 +1,139 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package slow
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateOfLargeShard() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		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())
+		}
+	}()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+
+	cls := articles.ParagraphsClass()
+	cls.ReplicationConfig = &models.ReplicationConfig{
+		Factor: 1,
+	}
+	cls.MultiTenancyConfig = &models.MultiTenancyConfig{
+		Enabled:              true,
+		AutoTenantActivation: true,
+		AutoTenantCreation:   true,
+	}
+
+	// Create the class
+	t.Log("Creating class", cls.Class)
+	helper.DeleteClass(t, cls.Class)
+	helper.CreateClass(t, cls)
+
+	// Load data
+	t.Log("Loading data into tenant...")
+	tenantName := "tenant"
+	batch := make([]*models.Object, 0, 100000)
+	start := time.Now()
+	for j := 0; j < 1000000; j++ {
+		batch = append(batch, (*models.Object)(articles.NewParagraph().
+			WithContents(fmt.Sprintf("paragraph#%d", j)).
+			WithTenant(tenantName).
+			Object()))
+		if len(batch) == 50000 {
+			helper.CreateObjectsBatch(t, batch)
+			t.Logf("Loaded %d objects", len(batch))
+			batch = batch[:0]
+		}
+	}
+	if len(batch) > 0 {
+		helper.CreateObjectsBatch(t, batch)
+		t.Logf("Loaded remaining %d objects", len(batch))
+	}
+	t.Logf("Data loading took %s", time.Since(start))
+
+	nodes, err := helper.Client(t).Nodes.NodesGet(nil, nil)
+	require.Nil(t, err)
+
+	nodeNames := make([]string, len(nodes.GetPayload().Nodes))
+	for i, node := range nodes.GetPayload().Nodes {
+		nodeNames[i] = node.Name
+	}
+
+	// Find node with shard
+	shardingState, err := helper.Client(t).Replication.GetCollectionShardingState(
+		replication.NewGetCollectionShardingStateParams().WithCollection(&cls.Class), nil,
+	)
+	require.Nil(t, err)
+	require.Len(t, shardingState.GetPayload().ShardingState.Shards, 1)
+
+	sourceNode := shardingState.GetPayload().ShardingState.Shards[0].Replicas[0]
+
+	targetNode := ""
+	for _, node := range nodeNames {
+		if node != sourceNode {
+			targetNode = node
+			break
+		}
+	}
+
+	move := models.ReplicationReplicateReplicaRequestTypeMOVE
+	t.Logf("Replicating from %s to %s", sourceNode, targetNode)
+	// Replicate the shard
+	res, err := helper.Client(t).Replication.Replicate(
+		replication.NewReplicateParams().
+			WithBody(&models.ReplicationReplicateReplicaRequest{
+				SourceNode: &sourceNode,
+				TargetNode: &targetNode,
+				Collection: &cls.Class,
+				Shard:      &shardingState.GetPayload().ShardingState.Shards[0].Shard,
+				Type:       &move,
+			}), nil,
+	)
+	require.Nil(t, err)
+	id := *res.GetPayload().ID
+
+	t.Logf("Replication started with ID: %s", id)
+	// Wait for replication to finish
+	t.Log("Waiting for replication to finish...")
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		status, err := helper.Client(t).Replication.ReplicationDetails(replication.NewReplicationDetailsParams().WithID(id), nil)
+		require.Nil(t, err)
+		require.Equal(ct, "READY", status.Payload.Status.State)
+	}, 180*time.Second, 100*time.Millisecond, "Replication operation should be in READY state")
+
+	t.Log("Replication completed successfully")
+	// Verify that the target node has the shard
+	shardingState, err = helper.Client(t).Replication.GetCollectionShardingState(
+		replication.NewGetCollectionShardingStateParams().WithCollection(&cls.Class), nil,
+	)
+	require.Nil(t, err)
+	require.Len(t, shardingState.GetPayload().ShardingState.Shards, 1)
+	require.Equal(t, targetNode, shardingState.GetPayload().ShardingState.Shards[0].Replicas[0])
+}

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

@@ -0,0 +1,190 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package slow
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/graphql"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/client/replication"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+type movement struct {
+	source string
+	target string
+	shard  string
+}
+
+func (suite *ReplicationTestSuite) TestReplicationReplicateScaleOut() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithWeaviateEnv("REPLICATION_ENGINE_MAX_WORKERS", "10").
+		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())
+		}
+	}()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+
+	cls := articles.ParagraphsClass()
+	cls.MultiTenancyConfig = &models.MultiTenancyConfig{
+		Enabled:              true,
+		AutoTenantActivation: true,
+		AutoTenantCreation:   true,
+	}
+	cls.ReplicationConfig = &models.ReplicationConfig{
+		Factor: 1,
+	}
+
+	// Create the class
+	helper.DeleteClass(t, cls.Class)
+	helper.CreateClass(t, cls)
+
+	// Load data
+	batch := make([]*models.Object, 0, 10000)
+	tenantNames := make([]string, 0, 100)
+	t.Log("Loading data into tenants...")
+	for i := 0; i < 100; i++ {
+		tenantName := fmt.Sprintf("tenant-%d", i)
+		tenantNames = append(tenantNames, tenantName)
+		for j := 0; j < 1000; j++ {
+			batch = append(batch, (*models.Object)(articles.NewParagraph().
+				WithContents(fmt.Sprintf("paragraph#%d", j)).
+				WithTenant(tenantName).
+				Object()))
+		}
+		if len(batch) == 10000 {
+			helper.CreateObjectsBatch(t, batch)
+			batch = batch[:0] // reset batch for next iteration
+		}
+	}
+	if len(batch) > 0 {
+		helper.CreateObjectsBatch(t, batch)
+	}
+
+	ns, err := helper.Client(t).Nodes.NodesGet(
+		nodes.NewNodesGetParams(), nil,
+	)
+	require.Nil(t, err)
+	nodeNames := make([]string, 0, len(ns.Payload.Nodes))
+	for _, node := range ns.Payload.Nodes {
+		nodeNames = append(nodeNames, node.Name)
+	}
+	require.Len(t, nodeNames, 3)
+
+	shardingState, err := helper.Client(t).Replication.GetCollectionShardingState(
+		replication.NewGetCollectionShardingStateParams().WithCollection(&cls.Class), nil,
+	)
+	require.Nil(t, err)
+	require.Len(t, shardingState.Payload.ShardingState.Shards, 100)
+
+	movements := []movement{}
+	for _, state := range shardingState.Payload.ShardingState.Shards {
+		replica := state.Replicas[0]
+		for _, node := range nodeNames {
+			if node == replica {
+				continue
+			}
+			movements = append(movements, movement{
+				source: replica,
+				target: node,
+				shard:  state.Shard,
+			})
+		}
+	}
+
+	t.Logf("Running %d scale out operations", len(movements))
+
+	for _, movement := range movements {
+		_, err = helper.Client(t).Replication.Replicate(
+			replication.NewReplicateParams().WithBody(&models.ReplicationReplicateReplicaRequest{
+				SourceNode: &movement.source,
+				TargetNode: &movement.target,
+				Shard:      &movement.shard,
+				Collection: &cls.Class,
+			}),
+			nil,
+		)
+		require.Nil(t, err, "failed to start replication from %s to %s for shard %s", movement.source, movement.target, movement.shard)
+		time.Sleep(10 * time.Millisecond) // Give some time to avoid overwhelming the server with requests
+	}
+	require.Nil(t, err, "failed to start batch replications")
+
+	// Wait until all ops are in the READY state
+	t.Log("Waiting for all replication operations to be in READY state...")
+	assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+		t.Log("Not all ops are in READY state, checking again...")
+		ops, err := helper.Client(t).Replication.ListReplication(
+			replication.NewListReplicationParams().WithCollection(&cls.Class), nil,
+		)
+		require.Nil(ct, err, "failed to list replication operations")
+		for _, op := range ops.Payload {
+			assert.Equal(ct, "READY", op.Status.State, "replication operation should be in READY state")
+		}
+	}, 10*time.Minute, 1*time.Second, "not all replication operations are in READY state")
+
+	// Assert that data is the same on each node
+	nodeToAddress := map[string]string{}
+	for idx, node := range ns.Payload.Nodes {
+		nodeToAddress[node.Name] = compose.GetWeaviateNode(idx + 1).URI()
+	}
+
+	objectCountByReplica := map[string]map[string]int64{}
+	for _, node := range nodeNames {
+		objectCountByReplica[node] = make(map[string]int64)
+	}
+	for _, tenantName := range tenantNames {
+		for node, address := range nodeToAddress {
+			helper.SetupClient(address)
+			res, err := helper.Client(t).Graphql.GraphqlPost(graphql.NewGraphqlPostParams().WithBody(&models.GraphQLQuery{
+				Query: fmt.Sprintf(`{ Aggregate { %s(tenant: "%s") { meta { count } } } }`, cls.Class, tenantName),
+			}), nil)
+			require.Nil(t, err, "failed to get object count for tenant %s on node %s", tenantName, node)
+			val, err := res.Payload.Data["Aggregate"].(map[string]any)["Paragraph"].([]any)[0].(map[string]any)["meta"].(map[string]any)["count"].(json.Number).Int64()
+			require.Nil(t, err, "failed to parse object count for tenant %s on node %s", tenantName, node)
+			objectCountByReplica[node][tenantName] = val
+		}
+	}
+
+	// Verify that all replicas have the same number of objects
+	t.Log("Verifying object counts across replicas")
+	var expectedCount int64
+	var comparisonReplica string
+	for _, tenantName := range tenantNames {
+		for replica, count := range objectCountByReplica {
+			actualCount, ok := count[tenantName]
+			require.True(t, ok, "object count for tenant %s not found on replica %s", tenantName, replica)
+			if expectedCount == 0 {
+				expectedCount = actualCount
+				comparisonReplica = replica
+			} else {
+				require.Equal(t, expectedCount, actualCount, "object counts across replicas do not match. Expected %d as on %s but got %d for replica %s instead", expectedCount, comparisonReplica, actualCount, replica)
+			}
+		}
+	}
+}