Add files using upload-large-folder tool

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

@@ -0,0 +1,107 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"os"
+	"path/filepath"
+)
+
+type Corpi struct {
+	Data     []Corpus
+	scanner  *bufio.Scanner
+	r        *rand.Rand
+	ds       Dataset
+	multiply int
+}
+
+type Corpus map[string]string
+
+func ParseCorpi(ds Dataset, multiply int) (*Corpi, error) {
+	p := filepath.Join(ds.Path, "corpus.jsonl")
+	f, err := os.Open(p)
+	if err != nil {
+		return nil, fmt.Errorf("open queries file at %s: %w", p, err)
+	}
+	scanner := bufio.NewScanner(f)
+	// we need reproducible random numbers to be able to compare different runs. This only needs to be stable for a
+	// given version of the code. If it produces different numbers after a dependency update it doesn't matter.
+	r := rand.New(rand.NewSource(9))
+
+	c := &Corpi{
+		Data:     []Corpus{},
+		scanner:  scanner,
+		r:        r,
+		ds:       ds,
+		multiply: multiply,
+	}
+
+	return c, nil
+}
+
+func (c *Corpi) Next(count int) error {
+	i := 0
+
+	c.Data = []Corpus{}
+
+	for i < count {
+
+		if !c.scanner.Scan() && c.scanner.Err() != nil {
+			return c.scanner.Err()
+		}
+
+		obj := map[string]interface{}{}
+		if err := json.Unmarshal(c.scanner.Bytes(), &obj); err != nil {
+			return err
+		}
+
+		corp := Corpus{}
+		for _, prop := range c.ds.Corpus.IndexedProperties {
+			propStr, ok := obj[prop].(string)
+			if !ok {
+				return fmt.Errorf("indexed property %s is not a string: %T",
+					prop, obj[prop])
+			}
+
+			corp[SanitizePropName(prop)] = propStr
+			for i := 1; i < c.multiply; i++ {
+				newName := fmt.Sprintf("%s_copy_%d", SanitizePropName(prop), i)
+				var propString string
+				if len(c.Data) > 1 { // get the content of the property from another object, to get more varied results
+					otherObjectIndex := c.r.Intn(len(corp))
+					propString = c.Data[otherObjectIndex][SanitizePropName(prop)]
+				} else {
+					propString = propStr
+				}
+				corp[newName] = propString
+			}
+		}
+
+		for _, prop := range c.ds.Corpus.UnindexedProperties {
+			propStr, ok := obj[prop].(string)
+			if !ok {
+				propStr = fmt.Sprintf("%v", obj[prop])
+			}
+
+			corp[SanitizePropName(prop)] = propStr
+		}
+
+		c.Data = append(c.Data, corp)
+		i++
+	}
+
+	return nil
+}

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

@@ -0,0 +1,92 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+)
+
+type Query struct {
+	Query       string
+	MatchingIds []int
+}
+
+type Queries []Query
+
+func ParseQueries(ds Dataset, limit int) (Queries, error) {
+	p := filepath.Join(ds.Path, "queries.jsonl")
+	f, err := os.Open(p)
+	if err != nil {
+		return nil, fmt.Errorf("open queries file at %s: %w", p, err)
+	}
+
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+
+	q := Queries{}
+	obj := map[string]interface{}{}
+	for scanner.Scan() {
+		if limit > 0 && len(q) >= limit {
+			break
+		}
+
+		if err := json.Unmarshal(scanner.Bytes(), &obj); err != nil {
+			return nil, err
+		}
+
+		queryStr, ok := obj[ds.Queries.Property].(string)
+		if !ok {
+			return nil, fmt.Errorf("property %s is not a string: %T",
+				ds.Queries.Property, obj[ds.Queries.Property])
+		}
+
+		var matchingIds []int
+		if ds.Queries.MatchingResults != "" {
+			matchingIdsInterface, ok := obj[ds.Queries.MatchingResults].([]interface{})
+			if !ok {
+				return nil, fmt.Errorf("property %s is not a []interface{}]: %T",
+					ds.Queries.MatchingResults, obj[ds.Queries.MatchingResults])
+			}
+			matchingIds = make([]int, len(matchingIdsInterface))
+			for i, val := range matchingIdsInterface {
+				// docIds can be provided as strings or float arrays
+				valStr, ok := val.(string)
+				if ok {
+					valInt, err := strconv.Atoi(valStr)
+					if err != nil {
+						return nil, err
+					}
+					matchingIds[i] = valInt
+
+				} else {
+					valFloat, ok := val.(float64)
+					if !ok {
+						return nil, fmt.Errorf("matching Id %v is not a float: %v", i, matchingIdsInterface)
+					}
+					matchingIds[i] = int(valFloat)
+				}
+
+			}
+
+		}
+
+		q = append(q, Query{Query: queryStr, MatchingIds: matchingIds})
+	}
+
+	return q, nil
+}

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

@@ -0,0 +1,56 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+type DatasetCfg struct {
+	Datasets []Dataset `yaml:"datasets"`
+}
+
+type Dataset struct {
+	ID      string         `yaml:"id"`
+	Path    string         `yaml:"path"`
+	Corpus  DatasetCorpus  `yaml:"corpus"`
+	Queries DatasetQueries `yaml:"queries"`
+}
+
+type DatasetCorpus struct {
+	IndexedProperties   []string `yaml:"indexed_properties"`
+	UnindexedProperties []string `yaml:"unindexed_properties"`
+}
+
+type DatasetQueries struct {
+	Property          string   `yaml:"property"`
+	MatchingResults   string   `yaml:"matching_results"`
+	PropertyWithId    string   `yaml:"property_with_id"`
+	PropertiesToMatch []string `yaml:"properties_to_match"`
+}
+
+func ParseDatasetConfig(filename string) (DatasetCfg, error) {
+	var config DatasetCfg
+	yamlFile, err := os.ReadFile(filename)
+	if err != nil {
+		return config, err
+	}
+
+	err = yaml.Unmarshal(yamlFile, &config)
+	if err != nil {
+		return config, err
+	}
+
+	return config, nil
+}

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

@@ -0,0 +1,60 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"fmt"
+	"sort"
+	"time"
+)
+
+type LatencyStats struct {
+	Min  time.Duration
+	Max  time.Duration
+	Mean time.Duration
+	P50  time.Duration
+	P90  time.Duration
+	P99  time.Duration
+}
+
+func AnalyzeLatencies(in []time.Duration) LatencyStats {
+	out := LatencyStats{}
+	sort.Slice(in, func(a, b int) bool { return in[a] < in[b] })
+
+	out.Min = in[0]
+	out.Max = in[len(in)-1]
+
+	sum := time.Duration(0)
+	for _, dur := range in {
+		sum += dur
+	}
+	out.Mean = sum / time.Duration(len(in))
+
+	out.P50 = in[len(in)/2]
+	out.P90 = in[len(in)*9/10]
+	out.P99 = in[len(in)*99/100]
+
+	return out
+}
+
+func (l LatencyStats) PrettyPrint() {
+	fmt.Printf("\n")
+	fmt.Printf("Query Latencies \n")
+	fmt.Printf("-------------------- \n")
+	fmt.Printf("Min:  %12s\n", l.Min)
+	fmt.Printf("Mean: %12s\n", l.Mean)
+	fmt.Printf("Max:  %12s\n", l.Max)
+	fmt.Printf("p50:  %12s\n", l.P50)
+	fmt.Printf("p90:  %12s\n", l.P90)
+	fmt.Printf("p99:  %12s\n", l.P99)
+	fmt.Printf("\n")
+}

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

@@ -0,0 +1,102 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"strings"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func SchemaFromDataset(ds Dataset, includeVectorizer bool) *models.Class {
+	out := &models.Class{}
+	out.Class = ClassNameFromDatasetID(ds.ID)
+	if !includeVectorizer {
+		out.VectorIndexConfig = map[string]interface{}{
+			"skip": true,
+		}
+		out.Vectorizer = "none"
+	}
+	out.InvertedIndexConfig = &models.InvertedIndexConfig{
+		Stopwords: &models.StopwordConfig{
+			Preset: "none",
+		},
+		UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+	}
+
+	for _, prop := range ds.Corpus.IndexedProperties {
+		t := true
+		// all indexed props are indexed as text
+		prop := &models.Property{
+			Name:            SanitizePropName(prop),
+			DataType:        schema.DataTypeText.PropString(),
+			Tokenization:    models.PropertyTokenizationWord,
+			IndexFilterable: &t,
+			IndexSearchable: &t,
+		}
+
+		out.Properties = append(out.Properties, prop)
+
+	}
+
+	for _, prop := range ds.Corpus.UnindexedProperties {
+		// all indexed props are indexed as text
+		f := false
+		prop := &models.Property{
+			Name:            SanitizePropName(prop),
+			DataType:        schema.DataTypeText.PropString(),
+			Tokenization:    models.PropertyTokenizationField,
+			IndexFilterable: &f,
+			IndexSearchable: &f,
+		}
+
+		out.Properties = append(out.Properties, prop)
+	}
+
+	filterProps := []*models.Property{
+		{
+			Name:     "modulo_10",
+			DataType: []string{"int"},
+		},
+		{
+			Name:     "modulo_100",
+			DataType: []string{"int"},
+		},
+		{
+			Name:     "modulo_1000",
+			DataType: []string{"int"},
+		},
+	}
+
+	out.Properties = append(out.Properties, filterProps...)
+
+	return out
+}
+
+func ClassNameFromDatasetID(in string) string {
+	if len(in) == 0 {
+		panic("zero length dataset name")
+	}
+
+	return strings.ToUpper(string(in[0])) + strings.ToLower(in[1:])
+}
+
+func SanitizePropName(in string) string {
+	if len(in) >= 2 && in[0] == '_' && in[1] != '_' {
+		// single leading underscore is reserved, but we can append another one
+		return "_" + in
+	}
+
+	return in
+}

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

@@ -0,0 +1,71 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lib
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+)
+
+type Scores struct {
+	NDCG       float64
+	hitsAt1    int
+	hitsAt5    int
+	numQueries int
+}
+
+func (n *Scores) AddResult(matchingIds []int, resultIds []interface{}, propNameWithId string) error {
+	IDCG := 0.
+	for j := 0; j < len(matchingIds); j++ {
+		IDCG += 1. / math.Log(float64(j+2.))
+	}
+
+	DCG := 0.
+	for rank, resultId := range resultIds {
+		id, err := strconv.Atoi(resultId.(map[string]interface{})[propNameWithId].(string))
+		for _, matchingId := range matchingIds {
+			if err != nil {
+				return err
+			}
+			if id == matchingId {
+				if rank == 0 {
+					n.hitsAt1 += 1
+				}
+				if rank < 5 {
+					n.hitsAt5 += 1
+				}
+				DCG += 1 / math.Log(float64(rank+2))
+
+			}
+		}
+	}
+	n.NDCG += DCG / IDCG
+	n.numQueries += 1
+	return nil
+}
+
+func (n *Scores) CurrentNDCG() float64 {
+	return n.NDCG / float64(n.numQueries)
+}
+
+func (n *Scores) CurrentPrecisionAt1() float64 {
+	return float64(n.hitsAt1) / float64(n.numQueries)
+}
+
+func (n *Scores) CurrentPrecisionAt5() float64 {
+	return float64(n.hitsAt5) / float64(n.numQueries) / float64(5)
+}
+
+func (n *Scores) PrettyPrint() {
+	fmt.Printf("nDCG score: %.04f, hits at 1: %d, hits at 5: %d\n", n.CurrentNDCG(), n.hitsAt1, n.hitsAt5)
+}

platform/dbops/binaries/weaviate-src/test/docker/mockoidc/Dockerfile

@@ -0,0 +1,10 @@
+FROM golang:alpine
+
+WORKDIR /app
+
+RUN go mod init mockoidc
+RUN go get github.com/weaviate/mockoidc@latest
+COPY mockoidc.go .
+RUN go build -o mockoidc .
+
+CMD ["/app/mockoidc"]

platform/dbops/binaries/weaviate-src/test/docker/mockoidc/mockoidc.go

@@ -0,0 +1,118 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package main
+
+import (
+	"crypto"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/pem"
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/weaviate/mockoidc"
+)
+
+const (
+	authCode     = "auth"
+	clientSecret = "Secret"
+	clientID     = "mock-oidc-test"
+)
+
+// This starts a mock OIDC server listening on 48001.
+// All codes to authenticate are hardcoded and the server returns tokens for two custom users:
+// - admin-user
+// - custom-user
+// afterwards the mockoidc default user is returned
+
+func main() {
+	getTLSConfig := func() *tls.Config {
+		certificate := os.Getenv("MOCK_CERTIFICATE")
+		certificateKey := os.Getenv("MOCK_CERTIFICATE_PRIVATE_KEY")
+		if certificate != "" && certificateKey != "" {
+			log.Println("Creating TLS config self signed certificates")
+			// read certificates
+			certBlock, _ := pem.Decode([]byte(certificate))
+			cert, err := x509.ParseCertificate(certBlock.Bytes)
+			if err != nil {
+				log.Fatalf("parse certificate: %v", err)
+			}
+			var privKey crypto.PrivateKey
+			keyBlock, _ := pem.Decode([]byte(certificateKey))
+			if keyBlock.Type == "RSA PRIVATE KEY" {
+				privKey, err = x509.ParsePKCS1PrivateKey(keyBlock.Bytes)
+				if err != nil {
+					log.Fatalf("parse certificate's private rsa key: %v", err)
+				}
+			} else {
+				privKey, err = x509.ParsePKCS8PrivateKey(keyBlock.Bytes)
+				if err != nil {
+					log.Fatalf("parse certificate's private key: %v", err)
+				}
+			}
+			// TLS configuration
+			tlsCert := tls.Certificate{
+				Certificate: [][]byte{cert.Raw},
+				PrivateKey:  privKey,
+			}
+			tlsConfig := &tls.Config{
+				Certificates: []tls.Certificate{tlsCert},
+				MinVersion:   tls.VersionTLS12,
+			}
+			return tlsConfig
+		}
+		// Default OIDC server
+		return nil
+	}
+	tlsConfig := getTLSConfig()
+	rsaKey, _ := rsa.GenerateKey(rand.Reader, 2048)
+	m, _ := mockoidc.NewServer(rsaKey)
+	m.ClientSecret = clientSecret
+	m.ClientID = clientID
+	hostname := os.Getenv("MOCK_HOSTNAME")
+	m.Hostname = fmt.Sprintf("%s:48001", hostname)
+	addr := "0.0.0.0:48001"
+	if hostname != "" {
+		addr = fmt.Sprintf("%s:48001", hostname)
+	}
+	ln, _ := net.Listen("tcp", addr)
+	m.Start(ln, tlsConfig)
+	defer m.Shutdown()
+
+	admin := &mockoidc.MockUser{Subject: "admin-user"}
+	m.QueueUser(admin)
+	m.QueueCode(authCode)
+
+	custom := &mockoidc.MockUser{Subject: "custom-user", Groups: []string{"custom-group"}}
+	m.QueueUser(custom)
+	m.QueueCode(authCode)
+
+	log.Printf("issuer: %v\n", m.Issuer())
+	log.Printf("discovery endpoint: %v\n", m.DiscoveryEndpoint())
+	// Create a channel to receive OS signals
+	sigChan := make(chan os.Signal, 1)
+	// Notify the channel of the interrupt signal (Ctrl+C)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
+
+	// Print a message indicating the program is running
+	log.Println("Program is running. Press Ctrl+C to stop.")
+
+	// Block until a signal is received
+	sig := <-sigChan
+	log.Printf("Received signal: %v. Shutting down...\n", sig)
+}

platform/dbops/binaries/weaviate-src/test/docker/mockoidchelper/Dockerfile

@@ -0,0 +1,9 @@
+FROM golang:alpine
+
+WORKDIR /app
+
+RUN go mod init mockoidc_helper
+COPY mockoidc_helper.go .
+RUN go build -o mockoidc_helper .
+
+CMD ["/app/mockoidc_helper"]

platform/dbops/binaries/weaviate-src/test/docker/mockoidchelper/mockoidc_helper.go

@@ -0,0 +1,221 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/json"
+	"encoding/pem"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+const (
+	authCode     = "auth"
+	clientSecret = "Secret"
+	clientID     = "mock-oidc-test"
+)
+
+type Response struct {
+	AccessToken  string `json:"accessToken"`
+	RefreshToken string `json:"refreshToken"`
+}
+
+type tokensHandler struct {
+	client                      *http.Client
+	authEndpoint, tokenEndpoint string
+}
+
+func newTokensHandler() (*tokensHandler, error) {
+	getEndpointsAndClient := func() (string, string, *http.Client, error) {
+		hostname := os.Getenv("MOCK_HOSTNAME")
+		certificate := os.Getenv("MOCK_CERTIFICATE")
+		if certificate != "" {
+			certBlock, _ := pem.Decode([]byte(certificate))
+			cert, err := x509.ParseCertificate(certBlock.Bytes)
+			if err != nil {
+				return "", "", nil, fmt.Errorf("failed to decode certificate: %w", err)
+			}
+
+			certPool := x509.NewCertPool()
+			certPool.AddCert(cert)
+
+			// Create an HTTP client with self signed certificate
+			client := &http.Client{
+				Transport: &http.Transport{
+					TLSClientConfig: &tls.Config{
+						RootCAs:    certPool,
+						MinVersion: tls.VersionTLS12,
+					},
+				},
+			}
+
+			// Adjust endpoints to use https
+			authEndpoint := "https://" + hostname + "/oidc/authorize"
+			tokenEndpoint := "https://" + hostname + "/oidc/token"
+
+			return authEndpoint, tokenEndpoint, client, nil
+		}
+		// Default HTTP client
+		client := &http.Client{}
+
+		authEndpoint := "http://" + hostname + "/oidc/authorize"
+		tokenEndpoint := "http://" + hostname + "/oidc/token"
+
+		return authEndpoint, tokenEndpoint, client, nil
+	}
+
+	authEndpoint, tokenEndpoint, client, err := getEndpointsAndClient()
+	if err != nil {
+		return nil, err
+	}
+	return &tokensHandler{authEndpoint: authEndpoint, tokenEndpoint: tokenEndpoint, client: client}, nil
+}
+
+func (t *tokensHandler) handler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	accessToken, refreshToken, err := getTokensFromMockOIDC(t.client, t.authEndpoint, t.tokenEndpoint)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+
+	response := Response{AccessToken: accessToken, RefreshToken: refreshToken}
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		http.Error(w, fmt.Sprintf("encode response: %v", err), http.StatusInternalServerError)
+	}
+}
+
+func getTokensFromMockOIDC(client *http.Client, authEndpoint, tokenEndpoint string) (string, string, error) {
+	// getting the token is a two-step process:
+	// 1) authorizing with the clientSecret, the return contains an auth-code. However, (dont ask me why) the OIDC flow
+	//    demands a redirect, so we will not get the return. In the mockserver, we can set the auth code to whatever
+	//    we want, so we simply will use the same code for each call. Note that even though we do not get the return, we
+	//    still need to make the request to initialize the session
+	// 2) call the token endpoint with the auth code. This returns an access and refresh token.
+	//
+	// The access token can be used to authenticate with weaviate and the refresh token can be used to get a new valid
+	// token in case the access token lifetime expires
+
+	data := url.Values{}
+	data.Set("response_type", "code")
+	data.Set("code", authCode)
+	data.Set("redirect_uri", "google.com") // needs to be present
+	data.Set("client_id", clientID)
+	data.Set("client_secret", clientSecret)
+	data.Set("state", "email")
+	data.Set("scope", "openid groups")
+	req, err := http.NewRequest("POST", authEndpoint, bytes.NewBufferString(data.Encode()))
+	if err != nil {
+		return "", "", err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	// not getting a useful return value as we dont provide a valid redirect
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", "", err
+	}
+	defer resp.Body.Close()
+
+	data2 := url.Values{}
+	data2.Set("grant_type", "authorization_code")
+	data2.Set("client_id", clientID)
+	data2.Set("client_secret", clientSecret)
+	data2.Set("code", authCode)
+	data2.Set("scope", "email")
+	data2.Set("state", "email")
+	req2, err := http.NewRequest("POST", tokenEndpoint, bytes.NewBufferString(data2.Encode()))
+	if err != nil {
+		return "", "", err
+	}
+	req2.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	resp2, err := client.Do(req2)
+	if err != nil {
+		return "", "", err
+	}
+	defer resp2.Body.Close()
+	body, _ := io.ReadAll(resp2.Body)
+	var tokenResponse map[string]interface{}
+	err = json.Unmarshal(body, &tokenResponse)
+	if err != nil {
+		return "", "", err
+	}
+	accessToken, ok := tokenResponse["id_token"].(string)
+	if !ok {
+		return "", "", fmt.Errorf("failed to get access token from: %v", tokenResponse)
+	}
+	refreshToken, ok := tokenResponse["refresh_token"].(string)
+	if !ok {
+		return "", "", fmt.Errorf("failed to get refresh token from: %v", tokenResponse)
+	}
+	return accessToken, refreshToken, nil
+}
+
+func main() {
+	// Create tokens handler
+	tk, err := newTokensHandler()
+	if err != nil {
+		log.Fatalf("Failed to create tokens handler: %v", err)
+	}
+	// Create a new ServeMux for routing
+	mux := http.NewServeMux()
+	mux.HandleFunc("/tokens", tk.handler)
+
+	// Create the HTTP server
+	server := &http.Server{
+		Addr:    ":8080",
+		Handler: mux,
+	}
+
+	go func() {
+		// Start the server
+		log.Println("Starting server on :8080")
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("Server failed to start: %v", err)
+		}
+	}()
+	defer func() {
+		// Perform graceful shutdown
+		if err := server.Shutdown(context.Background()); err != nil {
+			log.Fatalf("Server shutdown failed: %v", err)
+		}
+		log.Println("Server gracefully stopped")
+	}()
+
+	// Create a channel to receive OS signals
+	sigChan := make(chan os.Signal, 1)
+	// Notify the channel of the interrupt signal (Ctrl+C)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
+
+	// Print a message indicating the program is running
+	log.Println("Program is running. Press Ctrl+C to stop.")
+
+	// Block until a signal is received
+	sig := <-sigChan
+	log.Printf("Received signal: %v. Shutting down...\n", sig)
+}

platform/dbops/binaries/weaviate-src/test/helper/graphql/graphql_helper.go

@@ -0,0 +1,167 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package graphqlhelper
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/runtime"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/client/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+type GraphQLResult struct {
+	Result interface{}
+}
+
+// Perform a GraphQL request
+func QueryGraphQL(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, operation string, query string, variables map[string]interface{}) (*models.GraphQLResponse, error) {
+	var vars interface{} = variables
+	params := graphql.NewGraphqlPostParams().WithBody(&models.GraphQLQuery{OperationName: operation, Query: query, Variables: vars})
+	response, err := helper.Client(t).Graphql.GraphqlPost(params, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return response.Payload, nil
+}
+
+// Perform a GraphQL request with timeout
+func QueryGraphQLWithTimeout(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, operation string, query string, variables map[string]interface{}, timeout time.Duration) (*models.GraphQLResponse, error) {
+	var vars interface{} = variables
+	params := graphql.NewGraphqlPostParamsWithTimeout(timeout).WithBody(&models.GraphQLQuery{OperationName: operation, Query: query, Variables: vars})
+	response, err := helper.Client(t).Graphql.GraphqlPost(params, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return response.Payload, nil
+}
+
+// Perform a GraphQL request and call fatal on failure
+func QueryGraphQLOrFatal(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, operation string, query string, variables map[string]interface{}) *models.GraphQLResponse {
+	t.Helper()
+	response, err := QueryGraphQL(t, auth, operation, query, variables)
+	return getGraphQLResponseOrFatal(t, response, err)
+}
+
+// Perform a GraphQL request and call fatal on failure with timeout
+func QueryGraphQLOrFatalWithTimeout(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, operation string, query string, variables map[string]interface{}, timeout time.Duration) *models.GraphQLResponse {
+	t.Helper()
+	response, err := QueryGraphQLWithTimeout(t, auth, operation, query, variables, timeout)
+	return getGraphQLResponseOrFatal(t, response, err)
+}
+
+func getGraphQLResponseOrFatal(t *testing.T, response *models.GraphQLResponse, err error) *models.GraphQLResponse {
+	t.Helper()
+	if err != nil {
+		var parsedErr *graphql.GraphqlPostUnprocessableEntity
+		if !errors.As(err, &parsedErr) {
+			t.Fatalf("Expected the query to succeed, but failed due to: %#v, with message: %s", err, err.Error())
+		}
+		innerErr := parsedErr.Payload.Error[0]
+		t.Fatalf("Expected the query to succeed, but failed with unprocessable entity: %v, with message: %s", innerErr, innerErr.Message)
+	}
+	return response
+}
+
+// Perform a query and assert that it is successful
+func AssertGraphQL(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, query string) *GraphQLResult {
+	t.Helper()
+	response := QueryGraphQLOrFatal(t, auth, "", query, nil)
+	return getGraphQLResult(t, response)
+}
+
+// Perform a query and assert that it is successful with timeout
+func AssertGraphQLWithTimeout(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, timeout time.Duration, query string) *GraphQLResult {
+	t.Helper()
+	response := QueryGraphQLOrFatalWithTimeout(t, auth, "", query, nil, timeout)
+	return getGraphQLResult(t, response)
+}
+
+func getGraphQLResult(t *testing.T, response *models.GraphQLResponse) *GraphQLResult {
+	t.Helper()
+	if len(response.Errors) != 0 {
+		j, _ := json.Marshal(response.Errors)
+		t.Fatal("GraphQL resolved to an error:", string(j))
+	}
+
+	data := make(map[string]interface{})
+
+	// get rid of models.JSONData
+	for key, value := range response.Data {
+		data[key] = value
+	}
+
+	return &GraphQLResult{Result: data}
+}
+
+// Perform a query and assert that it has errors
+func ErrorGraphQL(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, query string) []*models.GraphQLError {
+	t.Helper()
+	response := QueryGraphQLOrFatal(t, auth, "", query, nil)
+
+	if len(response.Errors) == 0 {
+		j, _ := json.Marshal(response.Errors)
+		t.Fatal("GraphQL resolved to data:", string(j))
+	}
+
+	return response.Errors
+}
+
+// Drill down in the result
+func (g GraphQLResult) Get(paths ...string) *GraphQLResult {
+	current := g.Result
+	for _, path := range paths {
+		var ok bool
+		currentAsMap := (current.(map[string]interface{}))
+		current, ok = currentAsMap[path]
+		if !ok {
+			panic(fmt.Sprintf("Cannot get element %s in %#v; result: %#v", path, paths, g.Result))
+		}
+	}
+
+	return &GraphQLResult{
+		Result: current,
+	}
+}
+
+// Cast the result to a slice
+func (g *GraphQLResult) AsSlice() []interface{} {
+	return g.Result.([]interface{})
+}
+
+func Vec2String(v []float32) (s string) {
+	for _, n := range v {
+		s = fmt.Sprintf("%s, %f", s, n)
+	}
+	s = strings.TrimLeft(s, ", ")
+	return fmt.Sprintf("[%s]", s)
+}
+
+func ParseVec(t *testing.T, iVec []interface{}) []float32 {
+	vec := make([]float32, len(iVec))
+	for i, val := range iVec {
+		parsed, err := val.(json.Number).Float64()
+		require.Nil(t, err)
+		vec[i] = float32(parsed)
+	}
+	return vec
+}

platform/dbops/binaries/weaviate-src/test/helper/grpc/grpc_helper.go

@@ -0,0 +1,83 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package grpchelper
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/protobuf/types/known/structpb"
+
+	"github.com/stretchr/testify/require"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Search(t *testing.T, req *pb.SearchRequest) (*pb.SearchReply, error) {
+	return helper.ClientGRPC(t).Search(context.Background(), req)
+}
+
+func SearchWithTimeout(t *testing.T, req *pb.SearchRequest, timeout time.Duration) (*pb.SearchReply, error) {
+	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	return helper.ClientGRPC(t).Search(ctx, req)
+}
+
+func AssertSearch(t *testing.T, req *pb.SearchRequest) *pb.SearchReply {
+	t.Helper()
+	resp, err := Search(t, req)
+	require.Nil(t, err)
+	return resp
+}
+
+func AssertSearchWithTimeout(t *testing.T, req *pb.SearchRequest, timeout time.Duration) *pb.SearchReply {
+	t.Helper()
+	resp, err := SearchWithTimeout(t, req, timeout)
+	if err != nil {
+		t.Errorf("SearchWithTimeout failed: %v", err)
+	}
+	return resp
+}
+
+func BatchGRPCWithTenantAuth(t *testing.T, objects []*models.Object, key string) (*pb.BatchObjectsReply, error) {
+	var objectsGRPC []*pb.BatchObject
+
+	for _, obj := range objects {
+		props := &structpb.Struct{Fields: map[string]*structpb.Value{}}
+		for name, val := range obj.Properties.(map[string]interface{}) {
+			valTyped := val.(*structpb.Value)
+			props.Fields[name] = valTyped
+		}
+
+		objectsGRPC = append(objectsGRPC, &pb.BatchObject{
+			Tenant:     obj.Tenant,
+			Collection: obj.Class,
+			Uuid:       obj.ID.String(),
+			Properties: &pb.BatchObject_Properties{NonRefProperties: props},
+			// Vector is missing
+		},
+		)
+	}
+	req := &pb.BatchObjectsRequest{Objects: objectsGRPC}
+	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", fmt.Sprintf("Bearer %s", key))
+
+	return helper.ClientGRPC(t).BatchObjects(ctx, req)
+}
+
+func ToPtr[T any](val T) *T {
+	return &val
+}

platform/dbops/binaries/weaviate-src/test/helper/journey/backup_and_restore_journey.go

@@ -0,0 +1,260 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package journey
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/client/backups"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/books"
+)
+
+type vectorsConfigType string
+
+const (
+	vectorsLegacy vectorsConfigType = "legacy"
+	vectorsNamed  vectorsConfigType = "named"
+	vectorsMixed  vectorsConfigType = "mixed"
+)
+
+func backupAndRestoreJourneyTest(t *testing.T, weaviateEndpoint, backend string, vectorsConfigType vectorsConfigType, overrideName, overridePath string) {
+	if weaviateEndpoint != "" {
+		helper.SetupClient(weaviateEndpoint)
+	}
+
+	var booksClass *models.Class
+	switch vectorsConfigType {
+	case vectorsNamed:
+		booksClass = books.ClassNamedContextionaryVectorizer()
+	case vectorsMixed:
+		booksClass = books.ClassMixedContextionaryVectorizer()
+	default:
+		booksClass = books.ClassContextionaryVectorizer()
+	}
+	helper.CreateClass(t, booksClass)
+	defer helper.DeleteClass(t, booksClass.Class)
+
+	verifyThatAllBooksExist := func(t *testing.T) {
+		book := helper.AssertGetObject(t, booksClass.Class, books.Dune)
+		require.Equal(t, books.Dune, book.ID)
+		book = helper.AssertGetObject(t, booksClass.Class, books.ProjectHailMary)
+		require.Equal(t, books.ProjectHailMary, book.ID)
+		book = helper.AssertGetObject(t, booksClass.Class, books.TheLordOfTheIceGarden)
+		require.Equal(t, books.TheLordOfTheIceGarden, book.ID)
+	}
+
+	vectorsForDune := func() map[string][]float32 {
+		vectors := map[string][]float32{}
+		duneBook := helper.AssertGetObject(t, booksClass.Class, books.Dune)
+
+		if vectorsConfigType == vectorsNamed || vectorsConfigType == vectorsMixed {
+			for name := range booksClass.VectorConfig {
+				switch vec := duneBook.Vectors[name].(type) {
+				case []float32:
+					vectors[name] = vec
+				case [][]float32:
+					// do nothing
+				default:
+					// do nothing
+				}
+			}
+		}
+		if vectorsConfigType == vectorsLegacy || vectorsConfigType == vectorsMixed {
+			vectors["vector"] = duneBook.Vector
+		}
+		return vectors
+	}
+
+	backupID := "backup-1_named_vectors_" + string(vectorsConfigType)
+	t.Run("add data to Books schema", func(t *testing.T) {
+		for _, book := range books.Objects() {
+			helper.CreateObject(t, book)
+			helper.AssertGetObjectEventually(t, book.Class, book.ID)
+		}
+	})
+
+	t.Run("verify that Books objects exist", func(t *testing.T) {
+		verifyThatAllBooksExist(t)
+	})
+	initialVectors := vectorsForDune()
+
+	t.Run("verify invalid compression config", func(t *testing.T) {
+		// unknown compression level
+		resp, err := helper.CreateBackup(t, &models.BackupConfig{
+			CompressionLevel: "some-weird-config",
+		}, booksClass.Class, backend, backupID)
+
+		helper.AssertRequestFail(t, resp, err, func() {
+			var customErr *backups.BackupsCreateUnprocessableEntity
+			require.True(t, errors.As(err, &customErr), "not backups.BackupsCreateUnprocessableEntity")
+		})
+
+		// out of band cpu %
+		resp, err = helper.CreateBackup(t, &models.BackupConfig{
+			CPUPercentage: 120,
+		}, booksClass.Class, backend, backupID)
+		helper.AssertRequestFail(t, resp, err, func() {
+			var customErr *backups.BackupsCreateUnprocessableEntity
+			require.True(t, errors.As(err, &customErr), "not backups.BackupsCreateUnprocessableEntity")
+		})
+
+		// out of band chunkSize
+		resp, err = helper.CreateBackup(t, &models.BackupConfig{
+			ChunkSize: 1024,
+		}, booksClass.Class, backend, backupID)
+		helper.AssertRequestFail(t, resp, err, func() {
+			var customErr *backups.BackupsCreateUnprocessableEntity
+			require.True(t, errors.As(err, &customErr), "not backups.BackupsCreateUnprocessableEntity")
+		})
+	})
+
+	t.Run("start backup process", func(t *testing.T) {
+		params := backups.NewBackupsCreateParams().
+			WithBackend(backend).
+			WithBody(&models.BackupCreateRequest{
+				ID:      backupID,
+				Include: []string{booksClass.Class},
+				Config: &models.BackupConfig{
+					CPUPercentage:    80,
+					ChunkSize:        512,
+					CompressionLevel: models.BackupConfigCompressionLevelDefaultCompression,
+					Bucket:           overrideName,
+					Path:             overridePath,
+				},
+			})
+		resp, err := helper.Client(t).Backups.BackupsCreate(params, nil)
+
+		helper.AssertRequestOk(t, resp, err, func() {
+			meta := resp.GetPayload()
+			require.NotNil(t, meta)
+			require.Equal(t, models.BackupCreateStatusResponseStatusSTARTED, *meta.Status)
+		})
+	})
+
+	t.Run("verify that backup process is completed", func(t *testing.T) {
+		params := backups.NewBackupsCreateStatusParams().
+			WithBackend(backend).
+			WithID(backupID).
+			WithBucket(&overrideName).
+			WithPath(&overridePath)
+		for {
+			resp, err := helper.Client(t).Backups.BackupsCreateStatus(params, nil)
+			require.Nil(t, err)
+			require.NotNil(t, resp)
+
+			meta := resp.GetPayload()
+			require.NotNil(t, meta)
+
+			if err != nil {
+				t.Logf("failed to get backup status: %+v", err)
+			}
+
+			switch *meta.Status {
+			case models.BackupCreateStatusResponseStatusSUCCESS:
+				return
+			case models.BackupCreateStatusResponseStatusFAILED:
+				t.Errorf("failed to create backup, got response: %+v", meta)
+				return
+			default:
+				time.Sleep(1 * time.Second)
+			}
+		}
+	})
+
+	t.Run("verify that Books objects still exist", func(t *testing.T) {
+		verifyThatAllBooksExist(t)
+	})
+
+	t.Run("remove Books class", func(t *testing.T) {
+		helper.DeleteClass(t, booksClass.Class)
+	})
+
+	t.Run("verify that objects don't exist", func(t *testing.T) {
+		err := helper.AssertGetObjectFailsEventually(t, booksClass.Class, books.Dune)
+		require.NotNil(t, err)
+		err = helper.AssertGetObjectFailsEventually(t, booksClass.Class, books.ProjectHailMary)
+		require.NotNil(t, err)
+		err = helper.AssertGetObjectFailsEventually(t, booksClass.Class, books.TheLordOfTheIceGarden)
+		require.NotNil(t, err)
+	})
+
+	// out of band cpu %
+	t.Run("invalid restore request", func(t *testing.T) {
+		resp, err := helper.RestoreBackup(t, &models.RestoreConfig{
+			CPUPercentage: 180,
+			Bucket:        overrideName,
+			Path:          overridePath,
+		}, booksClass.Class, backend, backupID, map[string]string{}, false)
+		helper.AssertRequestFail(t, resp, err, func() {
+			var customErr *backups.BackupsRestoreUnprocessableEntity
+			require.True(t, errors.As(err, &customErr), "not backups.BackupsRestoreUnprocessableEntity")
+		})
+	})
+
+	t.Run("start restore process", func(t *testing.T) {
+		params := backups.NewBackupsRestoreParams().
+			WithBackend(backend).
+			WithID(backupID).
+			WithBody(&models.BackupRestoreRequest{
+				Include: []string{booksClass.Class},
+				Config: &models.RestoreConfig{
+					CPUPercentage: 80,
+					Bucket:        overrideName,
+					Path:          overridePath,
+				},
+			})
+		resp, err := helper.Client(t).Backups.BackupsRestore(params, nil)
+		helper.AssertRequestOk(t, resp, err, func() {
+			meta := resp.GetPayload()
+			require.NotNil(t, meta)
+			require.Equal(t, models.BackupCreateStatusResponseStatusSTARTED, *meta.Status)
+		})
+	})
+	t.Run("verify that restore process is completed", func(t *testing.T) {
+		params := backups.NewBackupsRestoreStatusParams().
+			WithBackend(backend).
+			WithID(backupID).
+			WithBucket(&overrideName).
+			WithPath(&overridePath)
+		for {
+			resp, err := helper.Client(t).Backups.BackupsRestoreStatus(params, nil)
+			require.Nil(t, err)
+			require.NotNil(t, resp)
+			meta := resp.GetPayload()
+			require.NotNil(t, meta)
+			switch *meta.Status {
+			case models.BackupRestoreStatusResponseStatusSUCCESS:
+				return
+			case models.BackupRestoreStatusResponseStatusFAILED:
+				t.Errorf("failed to restore backup, got response: %+v", meta)
+				return
+			default:
+				time.Sleep(1 * time.Second)
+			}
+		}
+	})
+
+	t.Run("verify that Books objects exist after restore", func(t *testing.T) {
+		verifyThatAllBooksExist(t)
+	})
+
+	t.Run("verify that vectors are the same after restore", func(t *testing.T) {
+		restoredVectors := vectorsForDune()
+		require.Equal(t, initialVectors, restoredVectors)
+	})
+}

platform/dbops/binaries/weaviate-src/test/helper/journey/backup_journey.go

@@ -0,0 +1,397 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package journey
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/helper"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+)
+
+type journeyType int
+
+const (
+	singleNodeJourney journeyType = iota
+	clusterJourney
+)
+
+type dataIntegrityCheck int
+
+const (
+	checkClassPresenceOnly = iota
+	checkClassAndDataPresence
+)
+
+const (
+	singleTenant = ""
+	multiTenant  = true
+)
+
+func backupJourney(t *testing.T, className, backend, basebackupID string,
+	journeyType journeyType, dataIntegrityCheck dataIntegrityCheck,
+	tenantNames []string, pqEnabled bool, nodeMapping map[string]string,
+	override bool, overrideBucket, overridePath string,
+) {
+	backupID := basebackupID
+	if override {
+		backupID = fmt.Sprintf("%s_%s", backupID, overrideBucket)
+	}
+
+	overrideString := ""
+
+	if override {
+		overrideString = fmt.Sprintf(" with override bucket: %s, path: %s", overrideBucket, overridePath)
+	}
+
+	if journeyType == clusterJourney && backend == "filesystem" {
+		t.Run("should fail backup/restore with local filesystem backend"+overrideString, func(t *testing.T) {
+			backupResp, err := helper.CreateBackup(t, helper.DefaultBackupConfig(), className, backend, backupID)
+			assert.Nil(t, backupResp)
+			assert.Error(t, err)
+
+			restoreResp, err := helper.RestoreBackup(t, helper.DefaultRestoreConfig(), className, backend, backupID, map[string]string{}, false)
+			assert.Nil(t, restoreResp)
+			assert.Error(t, err)
+		})
+		return
+	}
+
+	t.Run("create backup"+overrideString, func(t *testing.T) {
+		// Ensure cluster is in sync
+		if journeyType == clusterJourney {
+			time.Sleep(3 * time.Second)
+		}
+
+		cfg := helper.DefaultBackupConfig()
+
+		if override {
+			cfg.Bucket = overrideBucket
+			cfg.Path = overridePath
+		}
+
+		assert.EventuallyWithT(t, func(t1 *assert.CollectT) {
+			resp, err := helper.CreateBackup(t, cfg, className, backend, backupID)
+			helper.AssertRequestOk(t, resp, err, nil)
+			assert.Equal(t1, cfg.Bucket, resp.Payload.Bucket)
+			if cfg.Bucket != "" {
+				assert.Contains(t, resp.Payload.Path, cfg.Bucket)
+			}
+			if cfg.Path != "" {
+				assert.Contains(t, resp.Payload.Path, cfg.Path)
+			}
+			assert.Equal(t1, backupID, resp.Payload.ID)
+			assert.Equal(t1, className, resp.Payload.Classes[0])
+			assert.Equal(t1, "", resp.Payload.Error)
+			assert.Equal(t1, string(backup.Started), *resp.Payload.Status)
+		}, 240*time.Second, 500*time.Millisecond)
+
+		assert.EventuallyWithT(t, func(t1 *assert.CollectT) {
+			resp, err := helper.CreateBackupStatus(t, backend, backupID, overrideBucket, overridePath)
+			assert.Nil(t, err, "expected nil, got: %v", err)
+
+			assert.NotNil(t1, resp)
+			assert.NotNil(t1, resp.Payload)
+			assert.NotNil(t1, resp.Payload.Status)
+			assert.Equal(t1, backupID, resp.Payload.ID)
+			assert.Equal(t1, backend, resp.Payload.Backend)
+			assert.Contains(t1, resp.Payload.Path, overrideBucket)
+			assert.Contains(t1, resp.Payload.Path, overridePath)
+
+			assert.True(t1, (*resp.Payload.Status == "STARTED") || (*resp.Payload.Status == "SUCCESS"))
+		}, 120*time.Second, 1000*time.Millisecond)
+
+		assert.EventuallyWithT(t, func(t1 *assert.CollectT) {
+			statusResp, err := helper.CreateBackupStatus(t, backend, backupID, overrideBucket, overridePath)
+
+			helper.AssertRequestOk(t, statusResp, err, func() {
+				assert.NotNil(t1, statusResp)
+				assert.NotNil(t1, statusResp.Payload)
+				assert.NotNil(t1, statusResp.Payload.Status)
+				assert.Equal(t1, backupID, statusResp.Payload.ID)
+				assert.Equal(t1, backend, statusResp.Payload.Backend)
+				assert.Contains(t1, statusResp.Payload.Path, overrideBucket)
+				assert.Contains(t1, statusResp.Payload.Path, overridePath)
+			})
+
+			assert.Equal(t1, string(backup.Success), *statusResp.Payload.Status,
+				statusResp.Payload.Error)
+		}, 120*time.Second, 1000*time.Millisecond)
+	})
+
+	t.Run("delete class for restoration"+overrideString, func(t *testing.T) {
+		helper.DeleteClass(t, className)
+		time.Sleep(time.Second)
+	})
+
+	t.Run("restore backup"+overrideString, func(t *testing.T) {
+		cfg := helper.DefaultRestoreConfig()
+
+		if override {
+			cfg.Bucket = overrideBucket
+			cfg.Path = overridePath
+		}
+
+		t.Logf("cfg: %+v, className: %s, backend: %s, backupID: %s, nodeMapping: %+v\n", cfg, className, backend, backupID, nodeMapping)
+		resp, err := helper.RestoreBackup(t, cfg, className, backend, backupID, nodeMapping, false)
+		require.Nil(t, err, "expected nil, got: %v", err)
+		assert.Equal(t, backupID, resp.Payload.ID)
+		assert.Equal(t, backend, resp.Payload.Backend)
+		assert.Contains(t, resp.Payload.Path, overrideBucket)
+		assert.Contains(t, resp.Payload.Path, overridePath)
+
+		// wait for restore success
+		ticker := time.NewTicker(90 * time.Second)
+	wait:
+		for {
+			select {
+			case <-ticker.C:
+				break wait
+			default:
+				resp, err := helper.RestoreBackupStatus(t, backend, backupID, overrideBucket, overridePath)
+				helper.AssertRequestOk(t, resp, err, func() {
+					require.NotNil(t, resp)
+					require.NotNil(t, resp.Payload)
+					require.NotNil(t, resp.Payload.Status)
+					assert.Equal(t, backupID, resp.Payload.ID)
+					assert.Equal(t, backend, resp.Payload.Backend)
+					assert.Contains(t, resp.Payload.Path, overrideBucket)
+					assert.Contains(t, resp.Payload.Path, overridePath)
+				})
+
+				if *resp.Payload.Status == string(backup.Success) {
+					break wait
+				}
+				time.Sleep(1 * time.Second)
+			}
+		}
+
+		statusResp, err := helper.RestoreBackupStatus(t, backend, backupID, overrideBucket, overridePath)
+		helper.AssertRequestOk(t, statusResp, err, func() {
+			require.NotNil(t, statusResp)
+			require.NotNil(t, statusResp.Payload)
+			require.NotNil(t, statusResp.Payload.Status)
+			assert.Equal(t, backupID, resp.Payload.ID)
+			assert.Equal(t, backend, resp.Payload.Backend)
+			assert.Contains(t, resp.Payload.Path, overrideBucket)
+			assert.Contains(t, resp.Payload.Path, overridePath)
+		})
+
+		require.Equal(t, string(backup.Success), *statusResp.Payload.Status)
+	})
+
+	// Ensure that on restoring the class it is consistent on the followers
+	assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+		if tenantNames != nil {
+			for _, name := range tenantNames {
+				moduleshelper.EnsureClassExists(t, className, name)
+				if dataIntegrityCheck == checkClassAndDataPresence {
+					count := moduleshelper.GetClassCount(t, className, name)
+					assert.Equal(t, int64(500/len(tenantNames)), count)
+				}
+			}
+		} else {
+			moduleshelper.EnsureClassExists(t, className, singleTenant)
+			if dataIntegrityCheck == checkClassAndDataPresence {
+				count := moduleshelper.GetClassCount(t, className, singleTenant)
+				assert.Equal(t, int64(500), count)
+				if pqEnabled {
+					moduleshelper.EnsureCompressedVectorsRestored(t, className)
+				}
+			}
+		}
+	}, 5*time.Second, 500*time.Microsecond, "class doesn't exists in follower nodes")
+}
+
+func backupJourneyWithCancellation(t *testing.T, className, backend, basebackupID string, journeyType journeyType, overrideBucket, overridePath string) {
+	backupID := basebackupID
+	if overridePath != "" {
+		backupID = fmt.Sprintf("%s_%s", backupID, overrideBucket)
+	}
+	if journeyType == clusterJourney && backend == "filesystem" {
+		t.Run("should fail backup/restore with local filesystem backend", func(t *testing.T) {
+			backupResp, err := helper.CreateBackup(t, helper.DefaultBackupConfig(), className, backend, backupID)
+			assert.Nil(t, backupResp)
+			assert.Error(t, err)
+
+			restoreResp, err := helper.RestoreBackup(t, helper.DefaultRestoreConfig(), className, backend, backupID, map[string]string{}, false)
+			assert.Nil(t, restoreResp)
+			assert.Error(t, err)
+		})
+		return
+	}
+
+	t.Run("create and cancel backup", func(t *testing.T) {
+		// Ensure cluster is in sync
+		if journeyType == clusterJourney {
+			time.Sleep(5 * time.Second)
+		}
+		cfg := helper.DefaultBackupConfig()
+		cfg.Bucket = overrideBucket
+		cfg.Path = overridePath
+
+		resp, err := helper.CreateBackup(t, cfg, className, backend, backupID)
+		helper.AssertRequestOk(t, resp, err, nil)
+
+		t.Run("cancel backup", func(t *testing.T) {
+			require.Nil(t, helper.CancelBackup(t, backend, backupID))
+		})
+
+		// wait for cancellation
+		ticker := time.NewTicker(20 * time.Second)
+	wait:
+		for {
+			select {
+			case <-ticker.C:
+				break wait
+			default:
+				statusResp, err := helper.CreateBackupStatus(t, backend, backupID, overrideBucket, overridePath)
+				helper.AssertRequestOk(t, statusResp, err, func() {
+					require.NotNil(t, statusResp)
+					require.NotNil(t, statusResp.Payload)
+					require.NotNil(t, statusResp.Payload.Status)
+				})
+
+				if *statusResp.Payload.Status == string(backup.Cancelled) {
+					break wait
+				}
+				time.Sleep(500 * time.Millisecond)
+			}
+		}
+
+		statusResp, err := helper.CreateBackupStatus(t, backend, backupID, overrideBucket, overridePath)
+		helper.AssertRequestOk(t, statusResp, err, func() {
+			require.NotNil(t, statusResp)
+			require.NotNil(t, statusResp.Payload)
+			require.NotNil(t, statusResp.Payload.Status)
+			require.Equal(t, string(backup.Cancelled), *statusResp.Payload.Status)
+		})
+	})
+}
+
+func backupJourneyWithListing(t *testing.T, journeyType journeyType, className, backend, backupID string, overrideBucket, overridePath string) {
+	if journeyType == clusterJourney && backend == "filesystem" || overrideBucket != "" {
+		return
+	}
+	if overridePath != "" {
+		backupID = fmt.Sprintf("%s_%s", backupID, overrideBucket)
+	}
+	// Create a backup first
+	cfg := helper.DefaultBackupConfig()
+	if overrideBucket != "" {
+		cfg.Bucket = overrideBucket
+		cfg.Path = overridePath
+	}
+	resp, err := helper.CreateBackup(t, cfg, className, backend, fmt.Sprintf("%s_for_listing", backupID))
+	helper.AssertRequestOk(t, resp, err, nil)
+
+	// Wait for backup to complete
+	ticker := time.NewTicker(90 * time.Second)
+wait:
+	for {
+		select {
+		case <-ticker.C:
+			break wait
+		default:
+			resp, err := helper.CreateBackupStatus(t, backend, fmt.Sprintf("%s_for_listing", backupID), overrideBucket, overridePath)
+			helper.AssertRequestOk(t, resp, err, nil)
+			if *resp.Payload.Status == string(backup.Success) {
+				break wait
+			}
+			time.Sleep(1 * time.Second)
+		}
+	}
+
+	// List backups and verify
+	listResp, err := helper.ListBackup(t, backend)
+	helper.AssertRequestOk(t, listResp, err, func() {
+		require.NotNil(t, listResp)
+		require.NotNil(t, listResp.Payload)
+		// Verify that our backup is in the list
+		found := false
+		for _, b := range listResp.Payload {
+			if b.ID == fmt.Sprintf("%s_for_listing", backupID) {
+				found = true
+				assert.Equal(t, string(backup.Success), b.Status)
+				assert.Contains(t, b.Classes, className)
+				break
+			}
+		}
+		assert.True(t, found, "backup not found in list")
+	})
+}
+
+func addTestClass(t *testing.T, className string, multiTenant bool) {
+	class := &models.Class{
+		Class: className,
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		Properties: []*models.Property{
+			{
+				Name:         "contents",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+	}
+
+	if multiTenant {
+		class.MultiTenancyConfig = &models.MultiTenancyConfig{
+			Enabled: true,
+		}
+	}
+
+	helper.CreateClass(t, class)
+}
+
+func addTestObjects(t *testing.T, className string, tenantNames []string) {
+	const (
+		noteLengthMin = 4
+		noteLengthMax = 1024
+
+		batchSize  = 10
+		numBatches = 50
+	)
+
+	seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))
+	multiTenant := len(tenantNames) > 0
+
+	for i := 0; i < numBatches; i++ {
+		batch := make([]*models.Object, batchSize)
+		for j := 0; j < batchSize; j++ {
+			contentsLength := noteLengthMin + seededRand.Intn(noteLengthMax-noteLengthMin+1)
+			contents := helper.GetRandomString(contentsLength)
+
+			obj := models.Object{
+				Class:      className,
+				Properties: map[string]interface{}{"contents": contents},
+			}
+			if multiTenant {
+				obj.Tenant = tenantNames[i]
+			}
+			batch[j] = &obj
+		}
+		helper.CreateObjectsBatch(t, batch)
+	}
+}

platform/dbops/binaries/weaviate-src/test/helper/journey/backup_journey_tests.go

@@ -0,0 +1,81 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package journey
+
+import (
+	"testing"
+)
+
+// BackupJourneyTests_SingleNode this method gathers all backup related e2e tests
+func BackupJourneyTests_SingleNode(t *testing.T, weaviateEndpoint, backend, className, backupID string, tenantNames []string, override bool, overrideBucket, overrideLocation string) {
+	if len(tenantNames) > 0 {
+		t.Run("multi-tenant single node backup", func(t *testing.T) {
+			singleNodeBackupJourneyTest(t, weaviateEndpoint, backend, className, backupID, tenantNames, false, override, overrideBucket, overrideLocation)
+		})
+		t.Run("multi-tenant single node backup with empty class", func(t *testing.T) {
+			singleNodeBackupEmptyClassJourneyTest(t, weaviateEndpoint, backend, className, backupID+"_empty", tenantNames, override, overrideBucket, overrideLocation)
+		})
+	} else {
+		// This is a simple test which covers almost the same scenario as singleNodeBackupJourneyTest
+		// but is left here to be expanded in the future with a more complex example
+		// like adding there a new reference property and trying to run the test with 2 classes which
+		// one of those classes is a class with a reference property
+		t.Run("backup and restore Books", func(t *testing.T) {
+			backupAndRestoreJourneyTest(t, weaviateEndpoint, backend, vectorsLegacy, overrideBucket, overrideLocation)
+		})
+
+		t.Run("backup and restore Books with named vectors", func(t *testing.T) {
+			backupAndRestoreJourneyTest(t, weaviateEndpoint, backend, vectorsNamed, overrideBucket, overrideLocation)
+		})
+
+		t.Run("backup and restore Books with mixed vectors", func(t *testing.T) {
+			backupAndRestoreJourneyTest(t, weaviateEndpoint, backend, vectorsMixed, overrideBucket, overrideLocation)
+		})
+
+		t.Run("single-tenant single node backup", func(t *testing.T) {
+			singleNodeBackupJourneyTest(t, weaviateEndpoint, backend, className, backupID, nil, false, override, overrideBucket, overrideLocation)
+		})
+
+		t.Run("single-tenant single node backup with PQ", func(t *testing.T) {
+			singleNodeBackupJourneyTest(t, weaviateEndpoint, backend, className, backupID+"_pq", nil, true, override, overrideBucket, overrideLocation)
+		})
+	}
+}
+
+// BackupJourneyTests_Cluster this method gathers all backup related e2e tests to be run on a cluster
+func BackupJourneyTests_Cluster(t *testing.T, backend, className, backupID string,
+	tenantNames []string, override bool, overrideBucket, overrideLocation string, weaviateEndpoints ...string,
+) {
+	if len(weaviateEndpoints) <= 1 {
+		t.Fatal("must provide more than one node for cluster backup test")
+	}
+	coordinator := weaviateEndpoints[0]
+
+	if len(tenantNames) > 0 {
+		t.Run("multi-tenant cluster backup", func(t *testing.T) {
+			clusterBackupJourneyTest(t, backend, className, backupID+"mtcb",
+				coordinator, tenantNames, false, override, overrideBucket, overrideLocation, weaviateEndpoints[1:]...)
+		})
+		t.Run("multi-tenant cluster backup with empty class", func(t *testing.T) {
+			clusterBackupEmptyClassJourneyTest(t, backend, className, backupID+"_empty",
+				coordinator, tenantNames, override, overrideBucket, overrideLocation, weaviateEndpoints[1:]...)
+		})
+	} else {
+		t.Run("single-tenant cluster backup", func(t *testing.T) {
+			clusterBackupJourneyTest(t, backend, className, backupID+"_pq", coordinator, nil, true, override, overrideBucket, overrideLocation, weaviateEndpoints[1:]...)
+		})
+	}
+
+	t.Run("node mapping cluster backup", func(t *testing.T) {
+		clusterNodeMappingBackupJourneyTest(t, backend, className, backupID+"_with_node_mapping", coordinator, override, overrideBucket, overrideLocation, weaviateEndpoints[1:]...) // FIXME
+	})
+}

platform/dbops/binaries/weaviate-src/test/helper/journey/cancel_from_restart_journey.go

@@ -0,0 +1,85 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package journey
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func CancelFromRestartJourney(t *testing.T, cluster *docker.DockerCompose, nodeName, backend string) {
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+
+	nodeStopTimeout := 10 * time.Second
+	className := "CancelClass"
+	backupID := fmt.Sprintf("%s-backup-cancel", backend)
+	numObjects := 20_000
+	batchSize := 200
+
+	t.Run("create class", func(t *testing.T) {
+		helper.CreateClass(t, &models.Class{
+			Class: className,
+			Properties: []*models.Property{
+				{Name: "textProp", DataType: []string{"text"}},
+			},
+		})
+	})
+
+	t.Run("import data", func(t *testing.T) {
+		for i := 0; i < numObjects; i += batchSize {
+			batch := make([]*models.Object, batchSize)
+			for j := range batch {
+				batch[j] = &models.Object{
+					Class: className,
+					Properties: map[string]interface{}{
+						"textProp": fmt.Sprintf("object-%d", i+j),
+					},
+				}
+			}
+			helper.CreateObjectsBatch(t, batch)
+		}
+	})
+
+	t.Run("create backup", func(t *testing.T) {
+		resp, err := helper.CreateBackup(t, &models.BackupConfig{}, className, backend, backupID)
+		require.Nil(t, err)
+		require.NotNil(t, resp.Payload)
+		require.NotNil(t, resp.Payload.Status)
+		require.Equal(t, string(backup.Started), *resp.Payload.Status)
+	})
+
+	t.Run("restart node mid-backup", func(t *testing.T) {
+		err := cluster.Stop(ctx, nodeName, &nodeStopTimeout)
+		require.Nil(t, err)
+		err = cluster.Start(ctx, nodeName)
+		require.Nil(t, err)
+		helper.SetupClient(cluster.GetWeaviate().URI())
+	})
+
+	t.Run("validate that backup was set to CANCELED on restart", func(t *testing.T) {
+		resp, err := helper.CreateBackupStatus(t, backend, backupID, "", "")
+		require.Nil(t, err)
+		require.NotNil(t, resp)
+		require.NotNil(t, resp.Payload)
+		require.NotNil(t, resp.Payload.Status)
+		require.Equal(t, string(backup.Cancelled), *resp.Payload.Status)
+	})
+}

platform/dbops/binaries/weaviate-src/test/helper/journey/cluster_backup_journey.go

@@ -0,0 +1,138 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package journey
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func clusterBackupJourneyTest(t *testing.T, backend, className,
+	backupID, coordinatorEndpoint string, tenantNames []string, pqEnabled bool, override bool, overrideBucket, overrideLocation string,
+	nodeEndpoints ...string,
+) {
+	uploaderEndpoint := nodeEndpoints[rand.Intn(len(nodeEndpoints))]
+	helper.SetupClient(uploaderEndpoint)
+	t.Logf("uploader selected -> %s:%s", helper.ServerHost, helper.ServerPort)
+
+	if len(tenantNames) > 0 {
+		// upload data to a node other than the coordinator
+		t.Run(fmt.Sprintf("add test data to endpoint: %s", uploaderEndpoint), func(t *testing.T) {
+			addTestClass(t, className, multiTenant)
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenantNames {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+			addTestObjects(t, className, tenantNames)
+		})
+	} else {
+		// upload data to a node other than the coordinator
+		t.Run(fmt.Sprintf("add test data to endpoint: %s", uploaderEndpoint), func(t *testing.T) {
+			addTestClass(t, className, !multiTenant)
+			addTestObjects(t, className, nil)
+		})
+	}
+
+	if pqEnabled {
+		pq := map[string]interface{}{
+			"enabled":   true,
+			"segments":  1,
+			"centroids": 16,
+		}
+		helper.EnablePQ(t, className, pq)
+	}
+
+	helper.SetupClient(coordinatorEndpoint)
+	t.Logf("coordinator selected -> %s:%s", helper.ServerHost, helper.ServerPort)
+
+	// send backup requests to the chosen coordinator
+	t.Run(fmt.Sprintf("with coordinator endpoint: %s", coordinatorEndpoint), func(t *testing.T) {
+		backupJourney(t, className, backend, backupID, clusterJourney,
+			checkClassAndDataPresence, tenantNames, pqEnabled, map[string]string{}, override, overrideBucket, overrideLocation)
+	})
+
+	t.Run(fmt.Sprintf("cancelling with coordinator endpoint: %s", coordinatorEndpoint), func(t *testing.T) {
+		backupJourneyWithCancellation(t, className, backend, fmt.Sprintf("%s_with_cancellation", backupID), clusterJourney, overrideBucket, overrideLocation)
+	})
+
+	t.Run(fmt.Sprintf("listing backups with coordinator endpoint: %s", coordinatorEndpoint), func(t *testing.T) {
+		backupJourneyWithListing(t, clusterJourney, className, backend, backupID, overrideBucket, overrideLocation)
+	})
+
+	t.Run("cleanup", func(t *testing.T) {
+		helper.DeleteClass(t, className)
+	})
+}
+
+func clusterBackupEmptyClassJourneyTest(t *testing.T, backend, className, backupID,
+	coordinatorEndpoint string, tenantNames []string, override bool, overrideBucket, overridePath string, nodeEndpoints ...string,
+) {
+	uploaderEndpoint := nodeEndpoints[rand.Intn(len(nodeEndpoints))]
+	helper.SetupClient(uploaderEndpoint)
+	t.Logf("uploader selected -> %s:%s", helper.ServerHost, helper.ServerPort)
+
+	if len(tenantNames) > 0 {
+		// upload data to a node other than the coordinator
+		t.Run(fmt.Sprintf("add test data to endpoint: %s", uploaderEndpoint), func(t *testing.T) {
+			addTestClass(t, className, multiTenant)
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenantNames {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+	} else {
+		// upload data to a node other than the coordinator
+		t.Run(fmt.Sprintf("add test data to endpoint: %s", uploaderEndpoint), func(t *testing.T) {
+			addTestClass(t, className, !multiTenant)
+		})
+	}
+
+	helper.SetupClient(coordinatorEndpoint)
+	t.Logf("coordinator selected -> %s:%s", helper.ServerHost, helper.ServerPort)
+
+	// send backup requests to the chosen coordinator
+	t.Run(fmt.Sprintf("with coordinator endpoint: %s", coordinatorEndpoint), func(t *testing.T) {
+		backupJourney(t, className, backend, backupID, clusterJourney,
+			checkClassPresenceOnly, tenantNames, false, map[string]string{}, false, "", "")
+	})
+
+	t.Run("cleanup", func(t *testing.T) {
+		helper.DeleteClass(t, className)
+	})
+}
+
+func clusterNodeMappingBackupJourneyTest(t *testing.T, backend, className, backupID, coordinatorEndpoint string, override bool, overrideBucket, overridePath string, nodeEndpoints ...string) {
+	uploaderEndpoint := nodeEndpoints[rand.Intn(len(nodeEndpoints))]
+	helper.SetupClient(uploaderEndpoint)
+
+	t.Logf("uploader selected -> %s:%s", helper.ServerHost, helper.ServerPort)
+	t.Run(fmt.Sprintf("add test data to endpoint: %s", uploaderEndpoint), func(t *testing.T) {
+		addTestClass(t, className, !multiTenant)
+	})
+
+	// send backup requests to the chosen coordinator, with nodeMapping.
+	// for nodeMapping we simply reverse the node(s) around, where node1 is now node2 and node2 is now node1.
+	t.Run(fmt.Sprintf("with coordinator endpoint: %s", coordinatorEndpoint), func(t *testing.T) {
+		backupJourney(t, className, backend, backupID, clusterJourney, checkClassPresenceOnly, nil, false,
+			map[string]string{"node1": "node2", "node2": "node1"}, override, overrideBucket, overridePath)
+	})
+
+	t.Run("cleanup", func(t *testing.T) {
+		helper.DeleteClass(t, className)
+	})
+}

platform/dbops/binaries/weaviate-src/test/helper/journey/group_by_journey_tests.go

@@ -0,0 +1,197 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package journey
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/documents"
+)
+
+func GroupBySingleAndMultiShardTests(t *testing.T, weaviateEndpoint string) {
+	if weaviateEndpoint != "" {
+		helper.SetupClient(weaviateEndpoint)
+	}
+	// helper methods
+	getGroup := func(value interface{}) map[string]interface{} {
+		group := value.(map[string]interface{})["_additional"].(map[string]interface{})["group"].(map[string]interface{})
+		return group
+	}
+	getGroupHits := func(group map[string]interface{}) (string, []string) {
+		result := []string{}
+		hits := group["hits"].([]interface{})
+		for _, hit := range hits {
+			additional := hit.(map[string]interface{})["_additional"].(map[string]interface{})
+			result = append(result, additional["id"].(string))
+		}
+		groupedBy := group["groupedBy"].(map[string]interface{})
+		groupedByValue := groupedBy["value"].(string)
+		return groupedByValue, result
+	}
+	getContents := func(t *testing.T, group map[string]interface{}) []string {
+		result := []string{}
+		hits := group["hits"].([]interface{})
+		for _, hit := range hits {
+			content, ok := hit.(map[string]interface{})["content"].(string)
+			require.True(t, ok, "hits{content} cannot be empty")
+			result = append(result, content)
+		}
+		return result
+	}
+	// test methods
+	create := func(t *testing.T, multishard bool) {
+		for _, class := range documents.ClassesContextionaryVectorizer(multishard) {
+			helper.CreateClass(t, class)
+		}
+		for _, obj := range documents.Objects() {
+			helper.CreateObject(t, obj)
+			helper.AssertGetObjectEventually(t, obj.Class, obj.ID)
+		}
+
+		// wait for the objects to be indexed
+		// TODO: remove this sleep when we have a better way to determine when the objects are indexed
+		time.Sleep(3 * time.Second)
+	}
+	groupBy := func(t *testing.T, groupsCount, objectsPerGroup int) {
+		query := `
+		{
+			Get{
+				Passage(
+					nearObject:{
+						id: "00000000-0000-0000-0000-000000000001"
+					}
+					groupBy:{
+						path:["ofDocument"]
+						groups:%v
+						objectsPerGroup:%v
+					}
+				){
+					_additional{
+						id
+						group{
+							groupedBy{value}
+							count
+							maxDistance
+							minDistance
+							hits {
+								content
+								_additional{
+									id
+									distance
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		`
+		result := graphqlhelper.AssertGraphQL(t, helper.RootAuth, fmt.Sprintf(query, groupsCount, objectsPerGroup))
+		groups := result.Get("Get", "Passage").AsSlice()
+
+		require.Len(t, groups, groupsCount)
+
+		expectedResults := map[string][]string{}
+
+		groupedBy1 := `weaviate://localhost/Document/00000000-0000-0000-0000-000000000011`
+		expectedGroup1 := []string{
+			documents.PassageIDs[0].String(),
+			documents.PassageIDs[5].String(),
+			documents.PassageIDs[4].String(),
+			documents.PassageIDs[3].String(),
+			documents.PassageIDs[2].String(),
+			documents.PassageIDs[1].String(),
+		}
+		expectedResults[groupedBy1] = expectedGroup1
+
+		groupedBy2 := `weaviate://localhost/Document/00000000-0000-0000-0000-000000000012`
+		expectedGroup2 := []string{
+			documents.PassageIDs[6].String(),
+			documents.PassageIDs[7].String(),
+		}
+		expectedResults[groupedBy2] = expectedGroup2
+
+		groupsOrder := []string{groupedBy1, groupedBy2}
+
+		for i, current := range groups {
+			group := getGroup(current)
+			groupedBy, ids := getGroupHits(group)
+			assert.Equal(t, groupsOrder[i], groupedBy)
+			for j := range ids {
+				assert.Equal(t, expectedResults[groupedBy][j], ids[j])
+			}
+			contents := getContents(t, group)
+			for _, content := range contents {
+				assert.True(t, strings.HasPrefix(content, "Content of Passage"))
+			}
+		}
+	}
+	delete := func(t *testing.T) {
+		helper.DeleteClass(t, documents.Passage)
+		helper.DeleteClass(t, documents.Document)
+	}
+	// tests
+	tests := []struct {
+		name                    string
+		multishard              bool
+		groups, objectsPerGroup int
+	}{
+		{
+			name:            "single shard - 2 groups 10 objects per group",
+			multishard:      false,
+			groups:          2,
+			objectsPerGroup: 10,
+		},
+		{
+			name:            "multi shard -  2 groups 10 objects per group",
+			multishard:      true,
+			groups:          2,
+			objectsPerGroup: 10,
+		},
+		{
+			name:            "single shard -  1 groups 1 objects per group",
+			multishard:      false,
+			groups:          1,
+			objectsPerGroup: 1,
+		},
+		{
+			name:            "multi shard -  1 groups 1 objects per group",
+			multishard:      true,
+			groups:          1,
+			objectsPerGroup: 1,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Run("create", func(t *testing.T) {
+				create(t, tt.multishard)
+			})
+			t.Run("group by", func(t *testing.T) {
+				groupBy(t, tt.groups, tt.objectsPerGroup)
+			})
+			t.Run("delete", func(t *testing.T) {
+				delete(t)
+				// The delete is not strongly consistent but the create method will use a strongly consistent check to
+				// ensure that the class doesn't exists. Introduce the sleep to ensure we don't fail creating the class
+				// due to consistency issue on the subsequent run
+				time.Sleep(500 * time.Millisecond)
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/helper/journey/single_node_backup_override_journey.go

@@ -0,0 +1,94 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package journey
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func singleNodeBackupJourneyTest(t *testing.T,
+	weaviateEndpoint, backend, className, backupID string,
+	tenantNames []string, pqEnabled bool, overrideActive bool, overrideBucket, overridePath string,
+) {
+	if weaviateEndpoint != "" {
+		helper.SetupClient(weaviateEndpoint)
+	}
+
+	if len(tenantNames) > 0 {
+		t.Run("add test data", func(t *testing.T) {
+			addTestClass(t, className, multiTenant)
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenantNames {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+			addTestObjects(t, className, tenantNames)
+		})
+	} else {
+		t.Run("add test data", func(t *testing.T) {
+			addTestClass(t, className, !multiTenant)
+			addTestObjects(t, className, nil)
+		})
+	}
+
+	if pqEnabled {
+		pq := map[string]interface{}{
+			"enabled":   true,
+			"segments":  1,
+			"centroids": 16,
+		}
+		helper.EnablePQ(t, className, pq)
+	}
+
+	t.Run("single node backup", func(t *testing.T) {
+		backupJourney(t, className, backend, backupID, singleNodeJourney,
+			checkClassAndDataPresence, tenantNames, pqEnabled, map[string]string{}, overrideActive, overrideBucket, overridePath)
+	})
+
+	t.Run("cleanup", func(t *testing.T) {
+		helper.DeleteClass(t, className)
+	})
+}
+
+func singleNodeBackupEmptyClassJourneyTest(t *testing.T,
+	weaviateEndpoint, backend, className, backupID string,
+	tenantNames []string, overrideActive bool, overrideBucket, overridePath string,
+) {
+	if weaviateEndpoint != "" {
+		helper.SetupClient(weaviateEndpoint)
+	}
+
+	if len(tenantNames) <= 0 {
+		t.Skip("test is only relevant with tenancy enabled")
+	}
+
+	t.Run("add test class and tenant", func(t *testing.T) {
+		addTestClass(t, className, multiTenant)
+		tenants := make([]*models.Tenant, len(tenantNames))
+		for i := range tenantNames {
+			tenants[i] = &models.Tenant{Name: tenantNames[i]}
+		}
+		helper.CreateTenants(t, className, tenants)
+	})
+
+	t.Run("single node backup", func(t *testing.T) {
+		backupJourney(t, className, backend, backupID,
+			singleNodeJourney, checkClassPresenceOnly, tenantNames, false, map[string]string{}, overrideActive, overrideBucket, overridePath)
+	})
+
+	t.Run("cleanup", func(t *testing.T) {
+		helper.DeleteClass(t, className)
+	})
+}

platform/dbops/binaries/weaviate-src/test/helper/modules/modules_helper.go

@@ -0,0 +1,192 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package moduleshelper
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/storage"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+)
+
+func EnsureClassExists(t *testing.T, className string, tenant string) {
+	query := fmt.Sprintf("{Aggregate{%s", className)
+	if tenant != "" {
+		query += fmt.Sprintf("(tenant:%q)", tenant)
+	}
+	query += " { meta { count}}}}"
+	resp := graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+
+	class := resp.Get("Aggregate", className).Result.([]interface{})
+	require.Len(t, class, 1)
+}
+
+func EnsureCompressedVectorsRestored(t *testing.T, className string) {
+	query := fmt.Sprintf("{Get{%s(limit:1){_additional{vector}}}}", className)
+	resp := graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+
+	class := resp.Get("Get", className).Result.([]interface{})
+	require.Len(t, class, 1)
+	vecResp := class[0].(map[string]interface{})["_additional"].(map[string]interface{})["vector"].([]interface{})
+
+	searchVec := graphqlhelper.Vec2String(graphqlhelper.ParseVec(t, vecResp))
+
+	limit := 10
+	query = fmt.Sprintf(
+		"{Get{%s(nearVector:{vector:%s} limit:%d){_additional{vector}}}}",
+		className, searchVec, limit)
+	resp = graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+	class = resp.Get("Get", className).Result.([]interface{})
+	require.Len(t, class, limit)
+}
+
+func GetClassCount(t *testing.T, className string, tenant string) int64 {
+	query := fmt.Sprintf("{Aggregate{%s", className)
+	if tenant != "" {
+		query += fmt.Sprintf("(tenant:%q)", tenant)
+	}
+	query += " { meta { count}}}}"
+	resp := graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+
+	class := resp.Get("Aggregate", className).Result.([]interface{})
+	require.Len(t, class, 1)
+
+	meta := class[0].(map[string]interface{})["meta"].(map[string]interface{})
+
+	countPayload := meta["count"].(json.Number)
+
+	count, err := countPayload.Int64()
+	require.Nil(t, err)
+
+	return count
+}
+
+func CreateTestFiles(t *testing.T, dirPath string) []string {
+	count := 5
+	filePaths := make([]string, count)
+	var fileName string
+
+	for i := 0; i < count; i += 1 {
+		fileName = fmt.Sprintf("file_%d.db", i)
+		filePaths[i] = filepath.Join(dirPath, fileName)
+		file, err := os.Create(filePaths[i])
+		if err != nil {
+			t.Fatalf("failed to create test file '%s': %s", fileName, err)
+		}
+		fmt.Fprintf(file, "This is content of db file named %s", fileName)
+		file.Close()
+		t.Logf("Created test file: %s\n", filePaths[i])
+	}
+	return filePaths
+}
+
+func CreateGCSBucket(ctx context.Context, t *testing.T, projectID, bucketName string) {
+	assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+		opts := []option.ClientOption{option.WithoutAuthentication()}
+		if emulatorHost := os.Getenv("STORAGE_EMULATOR_HOST"); emulatorHost != "" {
+			opts = append(opts, option.WithEndpoint(emulatorHost))
+		}
+		client, err := storage.NewClient(ctx, opts...)
+		assert.Nil(t, err)
+		defer client.Close()
+
+		assert.Nil(t, client.Bucket(bucketName).Create(ctx, projectID, nil))
+	}, 10*time.Second, 500*time.Millisecond)
+}
+
+func DeleteGCSBucket(ctx context.Context, t *testing.T, bucketName string) {
+	assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+		opts := []option.ClientOption{option.WithoutAuthentication()}
+		if emulatorHost := os.Getenv("STORAGE_EMULATOR_HOST"); emulatorHost != "" {
+			opts = append(opts, option.WithEndpoint(emulatorHost))
+		}
+		client, err := storage.NewClient(ctx, opts...)
+		assert.Nil(t, err)
+		defer client.Close()
+
+		bucket := client.Bucket(bucketName)
+		// we do iterate over objects because GCP doesn't allow deleting non-empty buckets
+		it := bucket.Objects(ctx, nil)
+		for {
+			objAttrs, err := it.Next()
+			if errors.Is(err, iterator.Done) {
+				break
+			}
+			assert.Nil(t, err)
+
+			obj := bucket.Object(objAttrs.Name)
+			err = obj.Delete(ctx)
+			assert.Nil(t, err)
+		}
+		assert.Nil(t, bucket.Delete(ctx))
+	}, 5*time.Second, 500*time.Millisecond)
+}
+
+func CreateAzureContainer(ctx context.Context, t *testing.T, endpoint, containerName string) {
+	t.Log("Creating azure container", containerName)
+	assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+		// First try to create a client to check if Azurite is ready
+		connectionString := "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://%s/devstoreaccount1;"
+		client, err := azblob.NewClientFromConnectionString(fmt.Sprintf(connectionString, endpoint), nil)
+		assert.NoError(collect, err, "Failed to create Azure client")
+
+		// Try to list containers to verify connection
+		pager := client.NewListContainersPager(nil)
+		_, err = pager.NextPage(ctx)
+		assert.NoError(collect, err, "Failed to list containers (Azurite might not be ready)")
+
+		// Now try to create the container
+		_, err = client.CreateContainer(ctx, containerName, nil)
+		if err != nil {
+			var respErr *azcore.ResponseError
+			if errors.As(err, &respErr) && respErr.ErrorCode == "ContainerAlreadyExists" {
+				// Container already exists, we're good
+				return
+			}
+			assert.NoError(collect, err, "Failed to create container %s", containerName)
+		}
+	}, 10*time.Second, 1*time.Second)
+}
+
+func DeleteAzureContainer(ctx context.Context, t *testing.T, endpoint, containerName string) {
+	t.Log("Deleting azure container", containerName)
+	assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+		connectionString := "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://%s/devstoreaccount1;"
+		client, err := azblob.NewClientFromConnectionString(fmt.Sprintf(connectionString, endpoint), nil)
+		assert.NoError(collect, err, "Failed to create Azure client")
+
+		_, err = client.DeleteContainer(ctx, containerName, nil)
+		if err != nil {
+			var respErr *azcore.ResponseError
+			if errors.As(err, &respErr) && respErr.ErrorCode == "ContainerNotFound" {
+				// Container doesn't exist, which is fine for deletion
+				return
+			}
+			assert.NoError(collect, err, "Failed to delete container %s", containerName)
+		}
+	}, 10*time.Second, 1*time.Second)
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/articles/articles.go

@@ -0,0 +1,127 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package articles
+
+import (
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func ArticlesClass() *models.Class {
+	return &models.Class{
+		Class: "Article",
+		Properties: []*models.Property{
+			{
+				Name:         "title",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+			{
+				Name:     "hasParagraphs",
+				DataType: []string{"Paragraph"},
+			},
+		},
+	}
+}
+
+func ParagraphsClass() *models.Class {
+	return &models.Class{
+		Class: "Paragraph",
+		Properties: []*models.Property{
+			{
+				Name:     "contents",
+				DataType: schema.DataTypeText.PropString(),
+			},
+		},
+		Vectorizer: "none",
+	}
+}
+
+type Article models.Object
+
+func (a *Article) WithID(id strfmt.UUID) *Article {
+	a.ID = id
+	return a
+}
+
+func (a *Article) WithReferences(refs ...*models.SingleRef) *Article {
+	props := a.Properties.(map[string]interface{})
+	props["hasParagraphs"] = models.MultipleRef(refs)
+	return a
+}
+
+func (a *Article) WithTitle(title string) *Article {
+	props := a.Properties.(map[string]interface{})
+	props["title"] = title
+	return a
+}
+
+func (a *Article) WithTenant(tk string) *Article {
+	a.Tenant = tk
+	return a
+}
+
+func (a *Article) WithVector(vector []float32) *Article {
+	a.Vector = vector
+	return a
+}
+
+func (a *Article) Object() *models.Object {
+	obj := models.Object(*a)
+	return &obj
+}
+
+func NewArticle() *Article {
+	return &Article{
+		Class:      "Article",
+		ID:         strfmt.UUID(uuid.NewString()),
+		Properties: make(map[string]interface{}),
+	}
+}
+
+type Paragraph models.Object
+
+func (p *Paragraph) WithID(id strfmt.UUID) *Paragraph {
+	p.ID = id
+	return p
+}
+
+func (p *Paragraph) WithContents(contents string) *Paragraph {
+	props := p.Properties.(map[string]interface{})
+	props["contents"] = contents
+	return p
+}
+
+func (p *Paragraph) WithVector(vec []float32) *Paragraph {
+	p.Vector = vec
+	return p
+}
+
+func (p *Paragraph) WithTenant(tk string) *Paragraph {
+	p.Tenant = tk
+	return p
+}
+
+func (p *Paragraph) Object() *models.Object {
+	obj := models.Object(*p)
+	return &obj
+}
+
+func NewParagraph() *Paragraph {
+	return &Paragraph{
+		Class:      "Paragraph",
+		ID:         strfmt.UUID(uuid.NewString()),
+		Properties: make(map[string]interface{}),
+	}
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/books/books.go

@@ -0,0 +1,383 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package books
+
+import (
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/usecases/config"
+	"google.golang.org/protobuf/types/known/structpb"
+)
+
+const DefaultClassName = "Books"
+
+const (
+	Dune                  strfmt.UUID = "67b79643-cf8b-4b22-b206-6e63dbb4e000"
+	ProjectHailMary       strfmt.UUID = "67b79643-cf8b-4b22-b206-6e63dbb4e001"
+	TheLordOfTheIceGarden strfmt.UUID = "67b79643-cf8b-4b22-b206-6e63dbb4e002"
+)
+
+func ClassContextionaryVectorizer() *models.Class {
+	return class(DefaultClassName, "text2vec-contextionary")
+}
+
+func ClassModel2VecVectorizer() *models.Class {
+	return class(DefaultClassName, "text2vec-model2vec")
+}
+
+func ClassModel2VecVectorizerWithName(className string) *models.Class {
+	return class(className, "text2vec-model2vec")
+}
+
+func ClassOpenAIWithOptions() *models.Class {
+	c := class(DefaultClassName, "text2vec-openai")
+	c.ModuleConfig.(map[string]interface{})["text2vec-openai"] = map[string]interface{}{
+		"model":      "text-embedding-3-large",
+		"dimensions": 3072,
+	}
+	return c
+}
+
+func ClassNamedOpenAIWithOptions() *models.Class {
+	vc := map[string]models.VectorConfig{
+		"all": {
+			Vectorizer: map[string]interface{}{
+				"text2vec-openai": map[string]interface{}{
+					"model":      "text-embedding-3-large",
+					"dimensions": 3072,
+				},
+			},
+			VectorIndexType: "hnsw",
+		},
+	}
+	return classNamedVectors(DefaultClassName, vc)
+}
+
+func ClassNamedContextionaryVectorizer() *models.Class {
+	vc := map[string]models.VectorConfig{
+		"all": {
+			Vectorizer: map[string]interface{}{
+				"text2vec-contextionary": map[string]interface{}{
+					"vectorizeClassName": false,
+				},
+			},
+			VectorIndexType: "hnsw",
+		},
+		"title": {
+			Vectorizer: map[string]interface{}{
+				"text2vec-contextionary": map[string]interface{}{
+					"vectorizeClassName": false,
+					"properties":         []string{"title"},
+				},
+			},
+			VectorIndexType: "hnsw",
+		},
+		"description": {
+			Vectorizer: map[string]interface{}{
+				"text2vec-contextionary": map[string]interface{}{
+					"vectorizeClassName": false,
+					"properties":         []string{"description"},
+				},
+			},
+			VectorIndexType: "hnsw",
+		},
+	}
+
+	return classNamedVectors(DefaultClassName, vc)
+}
+
+func ClassMixedContextionaryVectorizer() *models.Class {
+	vc := map[string]models.VectorConfig{
+		"contextionary_all": {
+			Vectorizer: map[string]interface{}{
+				"text2vec-contextionary": map[string]interface{}{
+					"vectorizeClassName": true,
+				},
+			},
+			VectorIndexType: "hnsw",
+		},
+		"title": {
+			Vectorizer: map[string]interface{}{
+				"text2vec-contextionary": map[string]interface{}{
+					"vectorizeClassName": false,
+					"properties":         []string{"title"},
+				},
+			},
+			VectorIndexType: "hnsw",
+		},
+	}
+
+	return classBase(DefaultClassName, "text2vec-contextionary", vc)
+}
+
+func ClassContextionaryVectorizerWithName(className string) *models.Class {
+	return class(className, "text2vec-contextionary")
+}
+
+func ClassContextionaryVectorizerWithSumTransformers() *models.Class {
+	return class(DefaultClassName, "text2vec-contextionary", "sum-transformers")
+}
+
+func ClassContextionaryVectorizerWithQnATransformers() *models.Class {
+	return class(DefaultClassName, "text2vec-contextionary", "qna-transformers")
+}
+
+func ClassTransformersVectorizer() *models.Class {
+	return class(DefaultClassName, "text2vec-transformers")
+}
+
+func ClassTransformersVectorizerWithName(className string) *models.Class {
+	return class(className, "text2vec-transformers")
+}
+
+func ClassTransformersVectorizerWithQnATransformersWithName(className string) *models.Class {
+	return class(className, "text2vec-transformers", "qna-transformers")
+}
+
+func ClassCLIPVectorizer() *models.Class {
+	c := class(DefaultClassName, "multi2vec-clip")
+	c.ModuleConfig.(map[string]interface{})["multi2vec-clip"] = map[string]interface{}{
+		"textFields": []string{"title", "tags", "description"},
+	}
+	return c
+}
+
+func ClassBindVectorizer() *models.Class {
+	c := class(DefaultClassName, "multi2vec-bind")
+	c.ModuleConfig.(map[string]interface{})["multi2vec-bind"] = map[string]interface{}{
+		"textFields": []string{"title", "tags", "description"},
+	}
+	return c
+}
+
+func classNamedVectors(className string, vectorConfig map[string]models.VectorConfig, additionalModules ...string) *models.Class {
+	return classBase(className, "", vectorConfig, additionalModules...)
+}
+
+func class(className, vectorizer string, additionalModules ...string) *models.Class {
+	return classBase(className, vectorizer, nil, additionalModules...)
+}
+
+func classBase(className, vectorizer string, vectorConfig map[string]models.VectorConfig, additionalModules ...string) *models.Class {
+	moduleConfig := map[string]interface{}{}
+	propModuleConfig := map[string]interface{}{}
+	if vectorizer != "" {
+		moduleConfig[vectorizer] = map[string]interface{}{
+			"vectorizeClassName": true,
+		}
+		propModuleConfig[vectorizer] = map[string]interface{}{"skip": false}
+	}
+	if len(additionalModules) > 0 {
+		for _, module := range additionalModules {
+			moduleConfig[module] = map[string]interface{}{}
+		}
+	}
+
+	return &models.Class{
+		Class:        className,
+		Vectorizer:   vectorizer,
+		ModuleConfig: moduleConfig,
+		InvertedIndexConfig: &models.InvertedIndexConfig{
+			IndexNullState:      true,
+			IndexTimestamps:     true,
+			IndexPropertyLength: true,
+			UsingBlockMaxWAND:   config.DefaultUsingBlockMaxWAND,
+		},
+		VectorConfig: vectorConfig,
+		Properties: []*models.Property{
+			{
+				Name:         "title",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+				ModuleConfig: propModuleConfig,
+			},
+			{
+				Name:         "tags",
+				DataType:     schema.DataTypeTextArray.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+				ModuleConfig: propModuleConfig,
+			},
+			{
+				Name:         "description",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+				ModuleConfig: propModuleConfig,
+			},
+			{
+				Name: "meta", DataType: schema.DataTypeObject.PropString(),
+				NestedProperties: []*models.NestedProperty{
+					{Name: "isbn", DataType: schema.DataTypeText.PropString()},
+					{
+						Name: "obj", DataType: schema.DataTypeObject.PropString(),
+						NestedProperties: []*models.NestedProperty{{Name: "text", DataType: schema.DataTypeText.PropString()}},
+					},
+					{
+						Name: "objs", DataType: schema.DataTypeObjectArray.PropString(),
+						NestedProperties: []*models.NestedProperty{{Name: "text", DataType: schema.DataTypeText.PropString()}},
+					},
+				},
+			},
+			{
+				Name: "reviews", DataType: schema.DataTypeObjectArray.PropString(),
+				NestedProperties: []*models.NestedProperty{{Name: "tags", DataType: schema.DataTypeTextArray.PropString()}},
+			},
+		},
+	}
+}
+
+func Objects() []*models.Object {
+	return objects(DefaultClassName)
+}
+
+func BatchObjects() []*pb.BatchObject {
+	return batchObjects(DefaultClassName)
+}
+
+func ObjectsWithName(className string) []*models.Object {
+	return objects(className)
+}
+
+func objects(className string) []*models.Object {
+	return []*models.Object{
+		{
+			Class: className,
+			ID:    Dune,
+			Properties: map[string]interface{}{
+				"title":       "Dune",
+				"description": "Dune is a 1965 epic science fiction novel by American author Frank Herbert.",
+			},
+		},
+		{
+			Class: className,
+			ID:    ProjectHailMary,
+			Properties: map[string]interface{}{
+				"title":       "Project Hail Mary",
+				"description": "Project Hail Mary is a 2021 science fiction novel by American novelist Andy Weir.",
+			},
+		},
+		{
+			Class: className,
+			ID:    TheLordOfTheIceGarden,
+			Properties: map[string]interface{}{
+				"title":       "The Lord of the Ice Garden",
+				"tags":        []string{"three", "three", "three"},
+				"description": "The Lord of the Ice Garden (Polish: Pan Lodowego Ogrodu) is a four-volume science fiction and fantasy novel by Polish writer Jaroslaw Grzedowicz.",
+			},
+		},
+	}
+}
+
+func batchObjects(className string) []*pb.BatchObject {
+	scifi := "sci-fi"
+	return []*pb.BatchObject{
+		{
+			Collection: className,
+			Uuid:       Dune.String(),
+			Properties: &pb.BatchObject_Properties{
+				NonRefProperties: &structpb.Struct{
+					Fields: map[string]*structpb.Value{
+						"title":       structpb.NewStringValue("Dune"),
+						"description": structpb.NewStringValue("Dune is a 1965 epic science fiction novel by American author Frank Herbert."),
+					},
+				},
+				ObjectProperties: []*pb.ObjectProperties{{
+					PropName: "meta",
+					Value: &pb.ObjectPropertiesValue{
+						NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"isbn": structpb.NewStringValue("978-0593099322")}},
+						ObjectProperties: []*pb.ObjectProperties{{
+							PropName: "obj",
+							Value: &pb.ObjectPropertiesValue{
+								NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"text": structpb.NewStringValue("some text")}},
+							},
+						}},
+						ObjectArrayProperties: []*pb.ObjectArrayProperties{{
+							PropName: "objs",
+							Values: []*pb.ObjectPropertiesValue{{
+								NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"text": structpb.NewStringValue("some text")}},
+							}},
+						}},
+					},
+				}},
+				ObjectArrayProperties: []*pb.ObjectArrayProperties{{
+					PropName: "reviews",
+					Values:   []*pb.ObjectPropertiesValue{{TextArrayProperties: []*pb.TextArrayProperties{{PropName: "tags", Values: []string{scifi, "epic"}}}}},
+				}},
+			},
+		},
+		{
+			Collection: className,
+			Uuid:       ProjectHailMary.String(),
+			Properties: &pb.BatchObject_Properties{
+				NonRefProperties: &structpb.Struct{
+					Fields: map[string]*structpb.Value{
+						"title":       structpb.NewStringValue("Project Hail Mary"),
+						"description": structpb.NewStringValue("Project Hail Mary is a 2021 science fiction novel by American novelist Andy Weir."),
+					},
+				},
+				ObjectProperties: []*pb.ObjectProperties{{
+					PropName: "meta",
+					Value: &pb.ObjectPropertiesValue{
+						NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"isbn": structpb.NewStringValue("978-0593135204")}},
+						ObjectProperties: []*pb.ObjectProperties{{
+							PropName: "obj",
+							Value:    &pb.ObjectPropertiesValue{NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"text": structpb.NewStringValue("some text")}}},
+						}},
+						ObjectArrayProperties: []*pb.ObjectArrayProperties{{
+							PropName: "objs",
+							Values: []*pb.ObjectPropertiesValue{{
+								NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"text": structpb.NewStringValue("some text")}},
+							}},
+						}},
+					},
+				}},
+				ObjectArrayProperties: []*pb.ObjectArrayProperties{{
+					PropName: "reviews",
+					Values:   []*pb.ObjectPropertiesValue{{TextArrayProperties: []*pb.TextArrayProperties{{PropName: "tags", Values: []string{scifi}}}}},
+				}},
+			},
+		},
+		{
+			Collection: className,
+			Uuid:       TheLordOfTheIceGarden.String(),
+			Properties: &pb.BatchObject_Properties{
+				NonRefProperties: &structpb.Struct{
+					Fields: map[string]*structpb.Value{
+						"title":       structpb.NewStringValue("The Lord of the Ice Garden"),
+						"description": structpb.NewStringValue("The Lord of the Ice Garden (Polish: Pan Lodowego Ogrodu) is a four-volume science fiction and fantasy novel by Polish writer Jaroslaw Grzedowicz."),
+					},
+				},
+				ObjectProperties: []*pb.ObjectProperties{{
+					PropName: "meta",
+					Value: &pb.ObjectPropertiesValue{
+						NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"isbn": structpb.NewStringValue("978-8374812962")}},
+						ObjectProperties: []*pb.ObjectProperties{{
+							PropName: "obj",
+							Value:    &pb.ObjectPropertiesValue{NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"text": structpb.NewStringValue("some text")}}},
+						}},
+						ObjectArrayProperties: []*pb.ObjectArrayProperties{{
+							PropName: "objs",
+							Values: []*pb.ObjectPropertiesValue{{
+								NonRefProperties: &structpb.Struct{Fields: map[string]*structpb.Value{"text": structpb.NewStringValue("some text")}},
+							}},
+						}},
+					},
+				}},
+				ObjectArrayProperties: []*pb.ObjectArrayProperties{{
+					PropName: "reviews",
+					Values:   []*pb.ObjectPropertiesValue{{TextArrayProperties: []*pb.TextArrayProperties{{PropName: "tags", Values: []string{scifi, "fantasy"}}}}},
+				}},
+			},
+		},
+	}
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/cities/cities.go

@@ -0,0 +1,451 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package cities
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/schema/crossref"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+const (
+	Country = "Country"
+	City    = "City"
+	Airport = "Airport"
+)
+
+const (
+	Netherlands   strfmt.UUID = "67b79643-cf8b-4b22-b206-6e63dbb4e57a"
+	Germany       strfmt.UUID = "561eea29-b733-4079-b50b-cfabd78190b7"
+	Amsterdam     strfmt.UUID = "8f5f8e44-d348-459c-88b1-c1a44bb8f8be"
+	Rotterdam     strfmt.UUID = "660db307-a163-41d2-8182-560782cd018f"
+	Berlin        strfmt.UUID = "9b9cbea5-e87e-4cd0-89af-e2f424fd52d6"
+	Dusseldorf    strfmt.UUID = "6ffb03f8-a853-4ec5-a5d8-302e45aaaf13"
+	Missingisland strfmt.UUID = "823abeca-eef3-41c7-b587-7a6977b08003"
+	Nullisland    strfmt.UUID = "823abeca-eef3-41c7-b587-7a6977b08067"
+	Airport1      strfmt.UUID = "4770bb19-20fd-406e-ac64-9dac54c27a0f"
+	Airport2      strfmt.UUID = "cad6ab9b-5bb9-4388-a933-a5bdfd23db37"
+	Airport3      strfmt.UUID = "55a4dbbb-e2af-4b2a-901d-98146d1eeca7"
+	Airport4      strfmt.UUID = "62d15920-b546-4844-bc87-3ae33268fab5"
+)
+
+const (
+	HistoryAmsterdam  = "Due to its geographical location in what used to be wet peatland, the founding of Amsterdam is of a younger age than the founding of other urban centers in the Low Countries. However, in and around the area of what later became Amsterdam, local farmers settled as early as three millennia ago. They lived along the prehistoric IJ river and upstream of its tributary Amstel. The prehistoric IJ was a shallow and quiet stream in peatland behind beach ridges. This secluded area could grow there into an important local settlement center, especially in the late Bronze Age, the Iron Age and the Roman Age. Neolithic and Roman artefacts have also been found downstream of this area, in the prehistoric Amstel bedding under Amsterdam's Damrak and Rokin, such as shards of Bell Beaker culture pottery (2200-2000 BC) and a granite grinding stone (2700-2750 BC).[27][28] But the location of these artefacts around the river banks of the Amstel probably point to a presence of a modest semi-permanent or seasonal settlement of the previous mentioned local farmers. A permanent settlement would not have been possible, since the river mouth and the banks of the Amstel in this period in time were too wet for permanent habitation"
+	HistoryRotterdam  = "On 7 July 1340, Count Willem IV of Holland granted city rights to Rotterdam, whose population then was only a few thousand.[14] Around the year 1350, a shipping canal (the Rotterdamse Schie) was completed, which provided Rotterdam access to the larger towns in the north, allowing it to become a local trans-shipment centre between the Netherlands, England and Germany, and to urbanize"
+	HistoryBerlin     = "The earliest evidence of settlements in the area of today's Berlin are remnants of a house foundation dated to 1174, found in excavations in Berlin Mitte,[27] and a wooden beam dated from approximately 1192.[28] The first written records of towns in the area of present-day Berlin date from the late 12th century. Spandau is first mentioned in 1197 and Köpenick in 1209, although these areas did not join Berlin until 1920.[29] The central part of Berlin can be traced back to two towns. Cölln on the Fischerinsel is first mentioned in a 1237 document, and Berlin, across the Spree in what is now called the Nikolaiviertel, is referenced in a document from 1244.[28] 1237 is considered the founding date of the city.[30] The two towns over time formed close economic and social ties, and profited from the staple right on the two important trade routes Via Imperii and from Bruges to Novgorod.[12] In 1307, they formed an alliance with a common external policy, their internal administrations still being separated"
+	HistoryDusseldorf = "The first written mention of Düsseldorf (then called Dusseldorp in the local Low Rhenish dialect) dates back to 1135. Under Emperor Friedrich Barbarossa the small town of Kaiserswerth to the north of Düsseldorf became a well-fortified outpost, where soldiers kept a watchful eye on every movement on the Rhine. Kaiserswerth eventually became a suburb of Düsseldorf in 1929. In 1186, Düsseldorf came under the rule of the Counts of Berg. 14 August 1288 is one of the most important dates in the history of Düsseldorf. On this day the sovereign Count Adolf VIII of Berg granted the village on the banks of the Düssel town privileges. Before this, a bloody struggle for power had taken place between the Archbishop of Cologne and the count of Berg, culminating in the Battle of Worringen"
+)
+
+func CreateCountryCityAirportSchema(t *testing.T, host string) {
+	helper.SetupClient(host)
+	helper.CreateClass(t, &models.Class{
+		Class:      Country,
+		Vectorizer: "text2vec-contextionary",
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+	})
+
+	// City class has only one vectorizable field: "name"
+	// the rest of the fields are explicitly set to skip vectorization
+	// to not to downgrade the distance/certainty result on which the
+	// aggregate tests are based on.
+	helper.CreateClass(t, &models.Class{
+		Class:      City,
+		Vectorizer: "text2vec-contextionary",
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		InvertedIndexConfig: &models.InvertedIndexConfig{IndexNullState: true, IndexPropertyLength: true, IndexTimestamps: true, UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND},
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": false,
+					},
+				},
+			},
+			{
+				Name:     "inCountry",
+				DataType: []string{Country},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "population",
+				DataType: []string{"int"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "location",
+				DataType: []string{"geoCoordinates"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "isCapital",
+				DataType: []string{"boolean"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "cityArea",
+				DataType: []string{"number"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "cityRights",
+				DataType: []string{"date"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:         "timezones",
+				DataType:     schema.DataTypeTextArray.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "museums",
+				DataType: []string{"text[]"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "history",
+				DataType: []string{"text"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+			{
+				Name:     "phoneNumber",
+				DataType: []string{"phoneNumber"},
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"skip": true,
+					},
+				},
+			},
+		},
+	})
+
+	helper.CreateClass(t, &models.Class{
+		Class:      Airport,
+		Vectorizer: "text2vec-contextionary",
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		InvertedIndexConfig: &models.InvertedIndexConfig{
+			CleanupIntervalSeconds: 60,
+			Stopwords: &models.StopwordConfig{
+				Preset: "en",
+			},
+			IndexTimestamps:   true,
+			UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+		},
+		Properties: []*models.Property{
+			{
+				Name:         "code",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+			{
+				Name:     "phone",
+				DataType: []string{"phoneNumber"},
+			},
+			{
+				Name:     "inCity",
+				DataType: []string{City},
+			},
+			{
+				Name:     "airportId",
+				DataType: []string{"uuid"},
+			},
+		},
+	})
+}
+
+func InsertCountryCityAirportObjects(t *testing.T, host string) {
+	helper.SetupClient(host)
+	// countries
+	helper.CreateObject(t, &models.Object{
+		Class: Country,
+		ID:    Netherlands,
+		Properties: map[string]interface{}{
+			"name": "Netherlands",
+		},
+	})
+	helper.CreateObject(t, &models.Object{
+		Class: Country,
+		ID:    Germany,
+		Properties: map[string]interface{}{
+			"name": "Germany",
+		},
+	})
+
+	// cities
+	helper.CreateObject(t, &models.Object{
+		Class: City,
+		ID:    Amsterdam,
+		Properties: map[string]interface{}{
+			"name":       "Amsterdam",
+			"population": 1800000,
+			"location": map[string]interface{}{
+				"latitude":  52.366667,
+				"longitude": 4.9,
+			},
+			"inCountry": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(Country, Netherlands).String(),
+				},
+			},
+			"isCapital":  true,
+			"cityArea":   float64(891.95),
+			"cityRights": mustParseYear("1400"),
+			"timezones":  []string{"CET", "CEST"},
+			"museums":    []string{"Stedelijk Museum", "Rijksmuseum"},
+			"history":    HistoryAmsterdam,
+			"phoneNumber": map[string]interface{}{
+				"input": "+311000004",
+			},
+		},
+	})
+	helper.CreateObject(t, &models.Object{
+		Class: City,
+		ID:    Rotterdam,
+		Properties: map[string]interface{}{
+			"name":       "Rotterdam",
+			"population": 600000,
+			"inCountry": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(Country, Netherlands).String(),
+				},
+			},
+			"isCapital":  false,
+			"cityArea":   float64(319.35),
+			"cityRights": mustParseYear("1283"),
+			"timezones":  []string{"CET", "CEST"},
+			"museums":    []string{"Museum Boijmans Van Beuningen", "Wereldmuseum", "Witte de With Center for Contemporary Art"},
+			"history":    HistoryRotterdam,
+			"phoneNumber": map[string]interface{}{
+				"input": "+311000000",
+			},
+		},
+	})
+	helper.CreateObject(t, &models.Object{
+		Class: City,
+		ID:    Berlin,
+		Properties: map[string]interface{}{
+			"name":       "Berlin",
+			"population": 3470000,
+			"inCountry": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(Country, Germany).String(),
+				},
+			},
+			"isCapital":  true,
+			"cityArea":   float64(891.96),
+			"cityRights": mustParseYear("1400"),
+			"timezones":  []string{"CET", "CEST"},
+			"museums":    []string{"German Historical Museum"},
+			"history":    HistoryBerlin,
+			"phoneNumber": map[string]interface{}{
+				"input": "+311000002",
+			},
+		},
+	})
+	helper.CreateObject(t, &models.Object{
+		Class: City,
+		ID:    Dusseldorf,
+		Properties: map[string]interface{}{
+			"name":       "Dusseldorf",
+			"population": 600000,
+			"inCountry": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(Country, Germany).String(),
+				},
+			},
+			"location": map[string]interface{}{
+				"latitude":  51.225556,
+				"longitude": 6.782778,
+			},
+			"isCapital":  false,
+			"cityArea":   float64(217.22),
+			"cityRights": mustParseYear("1135"),
+			"timezones":  []string{"CET", "CEST"},
+			"museums":    []string{"Schlossturm", "Schiffahrt Museum", "Onomato"},
+			"history":    HistoryDusseldorf,
+			"phoneNumber": map[string]interface{}{
+				"input": "+311000001",
+			},
+		},
+	})
+
+	helper.CreateObject(t, &models.Object{
+		Class: City,
+		ID:    Missingisland,
+		Properties: map[string]interface{}{
+			"name":       "Missing Island",
+			"population": 0,
+			"location": map[string]interface{}{
+				"latitude":  0,
+				"longitude": 0,
+			},
+			"isCapital": false,
+		},
+	})
+
+	helper.CreateObject(t, &models.Object{
+		Class: City,
+		ID:    Nullisland,
+		Properties: map[string]interface{}{
+			"name":        nil,
+			"population":  nil,
+			"inCountry":   nil,
+			"location":    nil,
+			"isCapital":   nil,
+			"cityArea":    nil,
+			"cityRights":  nil,
+			"timezones":   nil,
+			"museums":     nil,
+			"history":     nil,
+			"phoneNumber": nil,
+		},
+	})
+
+	// airports
+	helper.CreateObject(t, &models.Object{
+		Class: Airport,
+		ID:    Airport1,
+		Properties: map[string]interface{}{
+			"code":      "10000",
+			"airportId": uuid.MustParse("00000000-0000-0000-0000-000000010000").String(),
+			"phone": map[string]interface{}{
+				"input": "+311234567",
+			},
+			"inCity": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(City, Amsterdam).String(),
+				},
+			},
+		},
+	})
+	helper.CreateObject(t, &models.Object{
+		Class: Airport,
+		ID:    Airport2,
+		Properties: map[string]interface{}{
+			"code":      "20000",
+			"airportId": uuid.MustParse("00000000-0000-0000-0000-000000020000").String(),
+			"inCity": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(City, Rotterdam).String(),
+				},
+			},
+		},
+	})
+	helper.CreateObject(t, &models.Object{
+		Class: Airport,
+		ID:    Airport3,
+		Properties: map[string]interface{}{
+			"code":      "30000",
+			"airportId": uuid.MustParse("00000000-0000-0000-0000-000000030000").String(),
+			"inCity": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(City, Dusseldorf).String(),
+				},
+			},
+		},
+	})
+	helper.CreateObject(t, &models.Object{
+		Class: Airport,
+		ID:    Airport4,
+		Properties: map[string]interface{}{
+			"code":      "40000",
+			"airportId": uuid.MustParse("00000000-0000-0000-0000-000000040000").String(),
+			"inCity": []interface{}{
+				map[string]interface{}{
+					"beacon": crossref.NewLocalhost(City, Berlin).String(),
+				},
+			},
+		},
+	})
+}
+
+func DeleteCountryCityAirportSchema(t *testing.T, host string) {
+	helper.SetupClient(host)
+	helper.DeleteClassObject(t, Airport)
+	helper.DeleteClassObject(t, City)
+	helper.DeleteClassObject(t, Country)
+}
+
+func mustParseYear(year string) time.Time {
+	date := fmt.Sprintf("%s-01-01T00:00:00+02:00", year)
+	asTime, err := time.Parse(time.RFC3339, date)
+	if err != nil {
+		panic(err)
+	}
+	return asTime
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/companies/companies.go

@@ -0,0 +1,265 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package companies
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/batch"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+)
+
+const DefaultTimeout = 2 * time.Minute
+
+const (
+	OpenAI strfmt.UUID = "00000000-0000-0000-0000-000000000001"
+	SpaceX strfmt.UUID = "00000000-0000-0000-0000-000000000002"
+)
+
+var Companies = []struct {
+	ID                strfmt.UUID
+	Name, Description string
+}{
+	{
+		ID:   OpenAI,
+		Name: "OpenAI",
+		Description: `OpenAI is a research organization and AI development company that focuses on artificial intelligence (AI) and machine learning (ML).
+				Founded in December 2015, OpenAI's mission is to ensure that artificial general intelligence (AGI) benefits all of humanity.
+				The organization has been at the forefront of AI research, producing cutting-edge advancements in natural language processing,
+				reinforcement learning, robotics, and other AI-related fields.
+
+				OpenAI has garnered attention for its work on various projects, including the development of the GPT (Generative Pre-trained Transformer)
+				series of models, such as GPT-2 and GPT-3, which have demonstrated remarkable capabilities in generating human-like text.
+				Additionally, OpenAI has contributed to advancements in reinforcement learning through projects like OpenAI Five, an AI system
+				capable of playing the complex strategy game Dota 2 at a high level.`,
+	},
+	{
+		ID:   SpaceX,
+		Name: "SpaceX",
+		Description: `SpaceX, short for Space Exploration Technologies Corp., is an American aerospace manufacturer and space transportation company
+				founded by Elon Musk in 2002. The company's primary goal is to reduce space transportation costs and enable the colonization of Mars,
+				among other ambitious objectives.
+
+				SpaceX has made significant strides in the aerospace industry by developing advanced rocket technology, spacecraft,
+				and satellite systems. The company is best known for its Falcon series of rockets, including the Falcon 1, Falcon 9, 
+				and Falcon Heavy, which have been designed with reusability in mind. Reusability has been a key innovation pioneered by SpaceX,
+				aiming to drastically reduce the cost of space travel by reusing rocket components multiple times.`,
+	},
+}
+
+func BaseClass(className string) *models.Class {
+	return &models.Class{
+		Class: className,
+		Properties: []*models.Property{
+			{
+				Name: "name", DataType: []string{schema.DataTypeText.String()},
+			},
+			{
+				Name: "description", DataType: []string{schema.DataTypeText.String()},
+			},
+		},
+	}
+}
+
+func InsertObjects(t *testing.T, host string, className string) {
+	for _, company := range Companies {
+		obj := &models.Object{
+			Class: className,
+			ID:    company.ID,
+			Properties: map[string]interface{}{
+				"name":        company.Name,
+				"description": company.Description,
+			},
+		}
+		helper.SetupClient(host)
+		err := helper.CreateObjectWithTimeout(t, obj, DefaultTimeout)
+		require.NoError(t, err)
+		getObj := helper.AssertGetObjectEventually(t, obj.Class, obj.ID)
+		require.NotNil(t, getObj)
+	}
+}
+
+func BatchInsertObjects(t *testing.T, host string, className string) {
+	var objects []*models.Object
+	for _, company := range Companies {
+		objects = append(objects, &models.Object{
+			Class: className,
+			ID:    company.ID,
+			Properties: map[string]interface{}{
+				"name":        company.Name,
+				"description": company.Description,
+			},
+		})
+	}
+	helper.SetupClient(host)
+
+	returnedFields := "ALL"
+	params := batch.NewBatchObjectsCreateParams().WithBody(
+		batch.BatchObjectsCreateBody{
+			Objects: objects,
+			Fields:  []*string{&returnedFields},
+		})
+
+	resp, err := helper.BatchClient(t).BatchObjectsCreate(params, nil)
+
+	// ensure that the response is OK
+	helper.AssertRequestOk(t, resp, err, func() {
+		objectsCreateResponse := resp.Payload
+
+		// check if the batch response contains two batched responses
+		assert.Equal(t, 2, len(objectsCreateResponse))
+
+		for _, elem := range resp.Payload {
+			assert.Nil(t, elem.Result.Errors)
+		}
+	})
+}
+
+func PerformAllSearchTests(t *testing.T, rest, grpc string, className string) {
+	// vector search with gql
+	t.Run("perform vector search with gql", func(t *testing.T) {
+		PerformVectorSearchTest(t, rest, className)
+	})
+	// vector search with grpc
+	t.Run("perform vector search with grpc", func(t *testing.T) {
+		PerformVectorSearchGRPCTest(t, grpc, className)
+	})
+	// hybrid search with gql
+	t.Run("perform hybrid search with gql", func(t *testing.T) {
+		PerformHybridSearchTest(t, rest, className)
+	})
+	// hybrid search with grpc
+	t.Run("perform hybrid search with grpc", func(t *testing.T) {
+		PerformHybridSearchGRPCTest(t, grpc, className)
+	})
+}
+
+func PerformVectorSearchTest(t *testing.T, host string, className string) {
+	query := fmt.Sprintf(`
+				{
+					Get {
+						%s(
+							nearText:{
+								concepts:["SpaceX"]
+							}
+						){
+							name
+							_additional {
+								id
+							}
+						}
+					}
+				}
+			`, className)
+	assertResults(t, host, className, query)
+}
+
+func PerformVectorSearchGRPCTest(t *testing.T, host string, className string) {
+	req := protocol.SearchRequest{
+		Collection: className,
+		NearText: &protocol.NearTextSearch{
+			Query: []string{"SpaceX"},
+		},
+		Properties: &protocol.PropertiesRequest{
+			NonRefProperties: []string{"name"},
+		},
+		Metadata: &protocol.MetadataRequest{
+			Uuid: true,
+		},
+		Uses_127Api: true,
+	}
+	assertResultsGRPC(t, host, &req)
+}
+
+func PerformHybridSearchWithTextTest(t *testing.T, host string, className, text string) {
+	query := fmt.Sprintf(`
+				{
+					Get {
+						%s(
+							hybrid:{
+								query:"%s"
+								alpha:0.75
+							}
+						){
+							name
+							_additional {
+								id
+							}
+						}
+					}
+				}
+			`, className, text)
+	assertResults(t, host, className, query)
+}
+
+func PerformHybridSearchTest(t *testing.T, host string, className string) {
+	PerformHybridSearchWithTextTest(t, host, className, "SpaceX")
+}
+
+func PerformHybridSearchGRPCTest(t *testing.T, host string, className string) {
+	req := protocol.SearchRequest{
+		Collection: className,
+		HybridSearch: &protocol.Hybrid{
+			Query: "SpaceX",
+			Alpha: 0.75,
+		},
+		Properties: &protocol.PropertiesRequest{
+			NonRefProperties: []string{"name"},
+		},
+		Metadata: &protocol.MetadataRequest{
+			Uuid: true,
+		},
+		Uses_127Api: true,
+	}
+	assertResultsGRPC(t, host, &req)
+}
+
+func assertResults(t *testing.T, host string, className, query string) {
+	helper.SetupClient(host)
+	result := graphqlhelper.AssertGraphQLWithTimeout(t, helper.RootAuth, DefaultTimeout, query)
+	objs := result.Get("Get", className).AsSlice()
+	require.Len(t, objs, 2)
+	for _, obj := range objs {
+		name := obj.(map[string]interface{})["name"]
+		assert.NotEmpty(t, name)
+		additional, ok := obj.(map[string]interface{})["_additional"].(map[string]interface{})
+		require.True(t, ok)
+		require.NotNil(t, additional)
+		id, ok := additional["id"].(string)
+		require.True(t, ok)
+		require.NotEmpty(t, id)
+	}
+}
+
+func assertResultsGRPC(t *testing.T, host string, req *protocol.SearchRequest) {
+	helper.SetupGRPCClient(t, host)
+	client := helper.ClientGRPC(t)
+	resp, err := client.Search(context.Background(), req)
+	if err != nil {
+		t.Fatalf("search request failed: %v", err)
+	}
+	require.Len(t, resp.Results, 2)
+	for _, res := range resp.Results {
+		assert.NotEmpty(t, res.GetProperties().GetNonRefProps().GetFields()["name"].GetTextValue())
+		assert.NotEmpty(t, res.GetMetadata().GetId())
+	}
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/documents/documents.go

@@ -0,0 +1,202 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package documents
+
+import (
+	"fmt"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema/crossref"
+)
+
+const (
+	Document = "Document"
+	Passage  = "Passage"
+)
+
+var DocumentIDs = []strfmt.UUID{
+	"00000000-0000-0000-0000-000000000011",
+	"00000000-0000-0000-0000-000000000012",
+}
+
+var PassageIDs = []strfmt.UUID{
+	"00000000-0000-0000-0000-000000000001",
+	"00000000-0000-0000-0000-000000000002",
+	"00000000-0000-0000-0000-000000000003",
+	"00000000-0000-0000-0000-000000000004",
+	"00000000-0000-0000-0000-000000000005",
+	"00000000-0000-0000-0000-000000000006",
+	"00000000-0000-0000-0000-000000000007",
+	"00000000-0000-0000-0000-000000000008",
+}
+
+var multiShardConfig = map[string]interface{}{
+	"actualCount":         float64(4),
+	"actualVirtualCount":  float64(128),
+	"desiredCount":        float64(4),
+	"desiredVirtualCount": float64(128),
+	"function":            "murmur3",
+	"key":                 "_id",
+	"strategy":            "hash",
+	"virtualPerPhysical":  float64(128),
+}
+
+var docTypes = []string{"private", "public"}
+
+func ClassesContextionaryVectorizer(multishard bool) []*models.Class {
+	return []*models.Class{
+		document("text2vec-contextionary", multishard),
+		passage("text2vec-contextionary", multishard),
+	}
+}
+
+func ClassesModel2VecVectorizer(multishard bool) []*models.Class {
+	return []*models.Class{
+		document("text2vec-model2vec", multishard),
+		passage("text2vec-model2vec", multishard),
+	}
+}
+
+func document(vectorizer string, multishard bool) *models.Class {
+	class := &models.Class{
+		Class:      Document,
+		Vectorizer: vectorizer,
+		ModuleConfig: map[string]interface{}{
+			vectorizer: map[string]interface{}{
+				"vectorizeClassName": false,
+			},
+		},
+		Properties: []*models.Property{
+			{
+				Name:     "title",
+				DataType: []string{"text"},
+				ModuleConfig: map[string]interface{}{
+					vectorizer: map[string]interface{}{
+						"vectorizePropertyName": false,
+					},
+				},
+			},
+			{
+				Name:     "pageCount",
+				DataType: []string{"int"},
+				ModuleConfig: map[string]interface{}{
+					vectorizer: map[string]interface{}{
+						"vectorizePropertyName": false,
+						"skip":                  true,
+					},
+				},
+			},
+			{
+				Name:     "docType",
+				DataType: []string{"text"},
+				ModuleConfig: map[string]interface{}{
+					vectorizer: map[string]interface{}{
+						"vectorizePropertyName": false,
+						"skip":                  true,
+					},
+				},
+			},
+		},
+	}
+	if multishard {
+		class.ShardingConfig = multiShardConfig
+	}
+	return class
+}
+
+func passage(vectorizer string, multishard bool) *models.Class {
+	class := &models.Class{
+		Class:      Passage,
+		Vectorizer: vectorizer,
+		ModuleConfig: map[string]interface{}{
+			vectorizer: map[string]interface{}{
+				"vectorizeClassName": false,
+			},
+		},
+		Properties: []*models.Property{
+			{
+				Name:     "content",
+				DataType: []string{"text"},
+				ModuleConfig: map[string]interface{}{
+					vectorizer: map[string]interface{}{
+						"vectorizePropertyName": false,
+					},
+				},
+			},
+			{
+				Name:     "ofDocument",
+				DataType: []string{Document},
+				ModuleConfig: map[string]interface{}{
+					vectorizer: map[string]interface{}{
+						"vectorizePropertyName": false,
+					},
+				},
+			},
+		},
+	}
+	if multishard {
+		class.ShardingConfig = multiShardConfig
+	}
+	return class
+}
+
+func Objects() []*models.Object {
+	return append(documentObjects(), passageObjects()...)
+}
+
+func documentObjects() []*models.Object {
+	getDocType := func(i int) string {
+		if i == 0 {
+			return docTypes[0]
+		}
+		return docTypes[1]
+	}
+	objects := make([]*models.Object, len(DocumentIDs))
+	for i, id := range DocumentIDs {
+		objects[i] = &models.Object{
+			Class: Document,
+			ID:    id,
+			Properties: map[string]interface{}{
+				"title":     fmt.Sprintf("Document title %v", i),
+				"pageCount": 100 + i,
+				"docType":   getDocType(i),
+			},
+		}
+	}
+	return objects
+}
+
+func passageObjects() []*models.Object {
+	getDocumentID := func(i int) strfmt.UUID {
+		if i < 6 {
+			return DocumentIDs[0]
+		}
+		return DocumentIDs[1]
+	}
+	objects := make([]*models.Object, len(PassageIDs))
+	for i, id := range PassageIDs {
+		objects[i] = &models.Object{
+			Class: Passage,
+			ID:    id,
+			Properties: map[string]interface{}{
+				"content": fmt.Sprintf("Content of Passage %v", i),
+				"ofDocument": []interface{}{
+					map[string]interface{}{
+						"beacon": crossref.NewLocalhost("Document", getDocumentID(i)).String(),
+					},
+				},
+			},
+		}
+	}
+	return objects
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/multimodal/data/data.csv

@@ -0,0 +1,3 @@
+,id,image_title,image_description,video_title,video_description
+0,00000000-0000-0000-0000-000000000001,"sunrise","Beautiful sunrise at the beach","cat","A cat cleaning himself with a paw"
+1,00000000-0000-0000-0000-000000000002,"waterfalls","A picture of Krka waterfalls in Croatia","dog","A dog giving a high five to a human"

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/multimodal/data/videos/1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebdc456b77069e3034049be754f566af2999cc98a2f9148f4f96c46b6d5e995a
+size 587027

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/multimodal/data/videos/2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48a31aae619f7a3557724501b91d0aadd4054269f4ff99b1ff8aa73466b124d0
+size 427446

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/multimodal/multimodal.go

@@ -0,0 +1,245 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package multimodal
+
+import (
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+)
+
+const DefaultTimeout = 2 * time.Minute
+
+const (
+	PropertyImageTitle       = "image_title"
+	PropertyImageDescription = "image_description"
+	PropertyImage            = "image"
+	PropertyVideoTitle       = "video_title"
+	PropertyVideoDescription = "video_description"
+	PropertyVideo            = "video"
+)
+
+func BaseClass(className string, withVideo bool) *models.Class {
+	properties := []*models.Property{
+		{
+			Name: PropertyImageTitle, DataType: []string{schema.DataTypeText.String()},
+		},
+		{
+			Name: PropertyImageDescription, DataType: []string{schema.DataTypeText.String()},
+		},
+		{
+			Name: PropertyImage, DataType: []string{schema.DataTypeBlob.String()},
+		},
+	}
+	if withVideo {
+		videoProperties := []*models.Property{
+			{
+				Name: PropertyVideoTitle, DataType: []string{schema.DataTypeText.String()},
+			},
+			{
+				Name: PropertyVideoDescription, DataType: []string{schema.DataTypeText.String()},
+			},
+			{
+				Name: PropertyVideo, DataType: []string{schema.DataTypeBlob.String()},
+			},
+		}
+		properties = append(properties, videoProperties...)
+	}
+	return &models.Class{
+		Class:      className,
+		Properties: properties,
+	}
+}
+
+func InsertObjects(t *testing.T, dataFolderPath, className string, withVideo bool) {
+	f, err := GetCSV(dataFolderPath)
+	require.NoError(t, err)
+	defer f.Close()
+	var objs []*models.Object
+	i := 0
+	csvReader := csv.NewReader(f)
+	for {
+		line, err := csvReader.Read()
+		if err == io.EOF {
+			break
+		}
+		require.NoError(t, err)
+		if i > 0 {
+			id := line[1]
+			imageTitle := line[2]
+			imageDescription := line[3]
+			imageBlob, err := GetImageBlob(dataFolderPath, i)
+			require.NoError(t, err)
+			properties := map[string]interface{}{
+				PropertyImageTitle:       imageTitle,
+				PropertyImageDescription: imageDescription,
+				PropertyImage:            imageBlob,
+			}
+			if withVideo {
+				videoTitle := line[4]
+				videoDescription := line[5]
+				videoBlob, err := GetVideoBlob(dataFolderPath, i)
+				require.NoError(t, err)
+				properties[PropertyVideoTitle] = videoTitle
+				properties[PropertyVideoDescription] = videoDescription
+				properties[PropertyVideo] = videoBlob
+			}
+
+			obj := &models.Object{
+				Class:      className,
+				ID:         strfmt.UUID(id),
+				Properties: properties,
+			}
+			objs = append(objs, obj)
+		}
+		i++
+	}
+	for _, obj := range objs {
+		err := helper.CreateObjectWithTimeout(t, obj, DefaultTimeout)
+		require.NoError(t, err)
+		obj := helper.AssertGetObjectEventually(t, obj.Class, obj.ID)
+		require.NotNil(t, obj)
+	}
+}
+
+func GetIDs(t *testing.T, dataFolderPath string) []string {
+	f, err := GetCSV(dataFolderPath)
+	require.NoError(t, err)
+	defer f.Close()
+	var ids []string
+	i := 0
+	csvReader := csv.NewReader(f)
+	for {
+		line, err := csvReader.Read()
+		if err == io.EOF {
+			break
+		}
+		require.NoError(t, err)
+		if i > 0 {
+			ids = append(ids, line[1])
+		}
+		i++
+	}
+	return ids
+}
+
+func CheckObjects(t *testing.T, dataFolderPath, className string, vectors, multivectors []string) {
+	for _, id := range GetIDs(t, dataFolderPath) {
+		t.Run(id, func(t *testing.T) {
+			obj, err := helper.GetObject(t, className, strfmt.UUID(id), "vector")
+			require.NoError(t, err)
+			require.NotNil(t, obj)
+			require.GreaterOrEqual(t, len(obj.Vectors), len(vectors)+len(multivectors))
+			for _, vec := range vectors {
+				require.IsType(t, []float32{}, obj.Vectors[vec])
+				require.True(t, len(obj.Vectors[vec].([]float32)) > 0)
+			}
+			for _, multivec := range multivectors {
+				require.IsType(t, [][]float32{}, obj.Vectors[multivec])
+				require.True(t, len(obj.Vectors[multivec].([][]float32)) > 0)
+			}
+		})
+	}
+}
+
+func GetImageBlob(dataFolderPath string, i int) (string, error) {
+	path := fmt.Sprintf("%s/images/%v.jpg", dataFolderPath, i)
+	return helper.GetBase64EncodedData(path)
+}
+
+func GetVideoBlob(dataFolderPath string, i int) (string, error) {
+	path := fmt.Sprintf("%s/videos/%v.mp4", dataFolderPath, i)
+	return helper.GetBase64EncodedData(path)
+}
+
+func GetCSV(dataFolderPath string) (*os.File, error) {
+	return os.Open(fmt.Sprintf("%s/data.csv", dataFolderPath))
+}
+
+// query test helper
+func TestQuery(t *testing.T,
+	className, nearMediaArgument, titleProperty, titlePropertyValue string,
+	targetVectors map[string]int,
+) {
+	var targetVectorsList []string
+	for targetVector := range targetVectors {
+		targetVectorsList = append(targetVectorsList, targetVector)
+	}
+	additionalVectors := ""
+	if len(targetVectorsList) > 0 {
+		additionalVectors = fmt.Sprintf("vectors {%s}", strings.Join(targetVectorsList, ","))
+	}
+	query := fmt.Sprintf(`
+			{
+				Get {
+					%s(
+						%s
+					){
+						%s
+						_additional {
+							certainty
+							%s
+						}
+					}
+				}
+			}
+		`, className, nearMediaArgument, titleProperty, additionalVectors)
+
+	result := graphqlhelper.AssertGraphQLWithTimeout(t, helper.RootAuth, DefaultTimeout, query)
+	objs := result.Get("Get", className).AsSlice()
+	require.Len(t, objs, 2)
+	title := objs[0].(map[string]interface{})[titleProperty]
+	assert.Equal(t, titlePropertyValue, title)
+	additional, ok := objs[0].(map[string]interface{})["_additional"].(map[string]interface{})
+	require.True(t, ok)
+	certainty := additional["certainty"].(json.Number)
+	assert.NotNil(t, certainty)
+	certaintyValue, err := certainty.Float64()
+	require.NoError(t, err)
+	assert.Greater(t, certaintyValue, 0.0)
+	assert.GreaterOrEqual(t, certaintyValue, 0.9)
+	if len(targetVectorsList) > 0 {
+		vectors, ok := additional["vectors"].(map[string]interface{})
+		require.True(t, ok)
+
+		targetVectorsMap := make(map[string][]float32)
+		for targetVector := range targetVectors {
+			vector, ok := vectors[targetVector].([]interface{})
+			require.True(t, ok)
+
+			vec := make([]float32, len(vector))
+			for i := range vector {
+				val, err := vector[i].(json.Number).Float64()
+				require.NoError(t, err)
+				vec[i] = float32(val)
+			}
+
+			targetVectorsMap[targetVector] = vec
+		}
+		for targetVector, targetVectorDimensions := range targetVectors {
+			require.Len(t, targetVectorsMap[targetVector], targetVectorDimensions)
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/multishard/multishard.go

@@ -0,0 +1,92 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package multishard
+
+import (
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+const (
+	MultiShardID1 strfmt.UUID = "aa44bbee-ca5f-4db7-a412-5fc6a23c534a"
+	MultiShardID2 strfmt.UUID = "aa44bbee-ca5f-4db7-a412-5fc6a23c534b"
+	MultiShardID3 strfmt.UUID = "aa44bbee-ca5f-4db7-a412-5fc6a23c534c"
+)
+
+func ClassContextionaryVectorizer() *models.Class {
+	return class("text2vec-contextionary")
+}
+
+func ClassTransformersVectorizer() *models.Class {
+	return class("text2vec-transformers")
+}
+
+func class(vectorizer string) *models.Class {
+	return &models.Class{
+		Class: "MultiShard",
+		ModuleConfig: map[string]interface{}{
+			vectorizer: map[string]interface{}{
+				"vectorizeClassName": false,
+			},
+		},
+		Vectorizer: vectorizer,
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+				ModuleConfig: map[string]interface{}{
+					vectorizer: map[string]interface{}{
+						"vectorizePropertyName": false,
+					},
+				},
+			},
+		},
+		ShardingConfig: map[string]interface{}{
+			"actualCount":         float64(2),
+			"actualVirtualCount":  float64(128),
+			"desiredCount":        float64(2),
+			"desiredVirtualCount": float64(128),
+			"function":            "murmur3",
+			"key":                 "_id",
+			"strategy":            "hash",
+			"virtualPerPhysical":  float64(128),
+		},
+	}
+}
+
+func Objects() []*models.Object {
+	return []*models.Object{
+		{
+			Class: "MultiShard",
+			ID:    MultiShardID1,
+			Properties: map[string]interface{}{
+				"name": "multi shard one",
+			},
+		},
+		{
+			Class: "MultiShard",
+			ID:    MultiShardID2,
+			Properties: map[string]interface{}{
+				"name": "multi shard two",
+			},
+		},
+		{
+			Class: "MultiShard",
+			ID:    MultiShardID3,
+			Properties: map[string]interface{}{
+				"name": "multi shard three",
+			},
+		},
+	}
+}

platform/dbops/binaries/weaviate-src/test/helper/sample-schema/planets/planets.go

@@ -0,0 +1,280 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package planets
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+)
+
+type Planet struct {
+	ID                         strfmt.UUID
+	Name, Description          string
+	Satellites                 []string
+	MeanRadius                 float64
+	IsHabitable                bool
+	SurfaceTemperaturesCelcius []float64
+}
+
+var Planets = []Planet{
+	{
+		ID:   strfmt.UUID("00000000-0000-0000-0000-000000000001"),
+		Name: "Earth",
+		Description: `
+		The Earth's surface is predominantly covered by oceans, accounting for about 71% of its total area, while continents provide 
+		the stage for bustling cities, towering mountains, and sprawling forests. Its atmosphere, composed mostly of nitrogen and oxygen, 
+		protects life from harmful solar radiation and regulates the planet's climate, creating the conditions necessary for life to flourish.
+
+		Humans, as the dominant species, have left an indelible mark on Earth, shaping its landscapes and ecosystems in profound ways. 
+		However, with this influence comes the responsibility to steward and preserve our planet for future generations.
+		`,
+		Satellites:                 []string{"Moon"},
+		MeanRadius:                 6371.0,
+		IsHabitable:                true,
+		SurfaceTemperaturesCelcius: []float64{-89.2, 14.76, 56.7},
+	},
+	{
+		ID:   strfmt.UUID("00000000-0000-0000-0000-000000000002"),
+		Name: "Mars",
+		Description: `
+		Mars, often called the "Red Planet" due to its rusty reddish hue, is the fourth planet from the Sun in our solar system. 
+		It's a world of stark contrasts and mysterious allure, captivating the imaginations of scientists, explorers, and dreamers alike.
+
+		With its barren, rocky terrain and thin atmosphere primarily composed of carbon dioxide, Mars presents a harsh environment vastly 
+		different from Earth. Yet, beneath its desolate surface lie tantalizing clues about its past, including evidence of ancient rivers, 
+		lakes, and even the possibility of microbial life.
+		`,
+		Satellites:                 []string{"Phobos", "Deimos"},
+		MeanRadius:                 3389.5,
+		IsHabitable:                false,
+		SurfaceTemperaturesCelcius: []float64{-110, -60, 35},
+	},
+}
+
+func BaseClass(className string) *models.Class {
+	return &models.Class{
+		Class: className,
+		Properties: []*models.Property{
+			{
+				Name: "name", DataType: []string{schema.DataTypeText.String()},
+			},
+			{
+				Name: "description", DataType: []string{schema.DataTypeText.String()},
+			},
+			{
+				Name: "image", DataType: []string{schema.DataTypeBlob.String()},
+			},
+			{
+				Name: "satellites", DataType: []string{string(schema.DataTypeTextArray.String())},
+			},
+			{
+				Name: "meanRadius", DataType: []string{string(schema.DataTypeNumber.String())},
+			},
+			{
+				Name: "isHabitable", DataType: []string{string(schema.DataTypeBoolean.String())},
+			},
+			{
+				Name: "surfaceTemperaturesCelcius", DataType: []string{string(schema.DataTypeNumberArray.String())},
+			},
+		},
+	}
+}
+
+func InsertObjects(t *testing.T, className string) {
+	InsertObjectsWithImages(t, className, "")
+}
+
+func InsertObjectsWithImages(t *testing.T, className, dataFolderPath string) {
+	getProperties := func(t *testing.T, planet Planet, dataFolderPath string) map[string]interface{} {
+		properties := map[string]interface{}{
+			"name":                       planet.Name,
+			"description":                planet.Description,
+			"satellites":                 planet.Satellites,
+			"meanRadius":                 planet.MeanRadius,
+			"isHabitable":                planet.IsHabitable,
+			"surfaceTemperaturesCelcius": planet.SurfaceTemperaturesCelcius,
+		}
+		if dataFolderPath != "" {
+			imageBase64, err := GetImageBlob(dataFolderPath, strings.ToLower(planet.Name))
+			require.NoError(t, err)
+			properties["image"] = imageBase64
+		}
+		return properties
+	}
+	for _, planet := range Planets {
+		obj := &models.Object{
+			Class:      className,
+			ID:         planet.ID,
+			Properties: getProperties(t, planet, dataFolderPath),
+		}
+		helper.CreateObject(t, obj)
+		helper.AssertGetObjectEventually(t, obj.Class, obj.ID)
+	}
+}
+
+func CreateTweetTest(t *testing.T, className string) {
+	CreateTweetTestWithParams(t, className, "")
+}
+
+func CreateTweetTestWithParams(t *testing.T, className, params string) {
+	CreatePromptTestWithParams(t, className, "Write a short tweet about planet {name}", params)
+}
+
+func CreatePromptTestWithParams(t *testing.T, className, prompt, params string) {
+	CreatePromptTestWithParamsWithDebug(t, className, prompt, params, false)
+}
+
+func CreatePromptTestWithParamsWithDebug(t *testing.T, className, prompt, params string, debug bool) {
+	debugParams := []string{"", ""}
+	if debug {
+		debugParams = []string{"debug:true", "debug{prompt}"}
+	}
+	query := fmt.Sprintf(`
+			{
+				Get {
+					%s{
+						name
+						_additional {
+							generate(
+								singleResult: {
+									prompt: """
+										%s
+									"""
+									%s
+									%s
+								}
+							) {
+								singleResult
+								error
+								%s
+							}
+						}
+					}
+				}
+			}
+		`, className, prompt, params, debugParams[0], debugParams[1])
+	result := graphqlhelper.AssertGraphQLWithTimeout(t, helper.RootAuth, 10*time.Minute, query)
+	objs := result.Get("Get", className).AsSlice()
+	require.Len(t, objs, 2)
+	for i, obj := range objs {
+		name := obj.(map[string]interface{})["name"]
+		assert.NotEmpty(t, name)
+		additional, ok := obj.(map[string]interface{})["_additional"].(map[string]interface{})
+		require.True(t, ok)
+		require.NotNil(t, additional)
+		generate, ok := additional["generate"].(map[string]interface{})
+		require.True(t, ok)
+		require.NotNil(t, generate)
+		require.Nil(t, generate["error"])
+		require.NotNil(t, generate["singleResult"])
+		singleResult, ok := generate["singleResult"].(string)
+		require.True(t, ok)
+		require.NotEmpty(t, singleResult)
+		// print the results of the prompt
+		if debug {
+			debugResult, ok := generate["debug"].(map[string]interface{})
+			require.True(t, ok)
+			require.NotNil(t, debugResult["prompt"])
+			debugPrompt, ok := debugResult["prompt"].(string)
+			require.True(t, ok)
+			t.Logf("---------------\n[%v]Prompt: %s\n[%v]Debug.prompt: %v\n[%v]Result: %s\n---------------\n", i, prompt, i, debugPrompt, i, singleResult)
+		} else {
+			t.Logf("---------------\n[%v]Prompt: %s\n[%v]Result: %s\n---------------\n", i, prompt, i, singleResult)
+		}
+	}
+}
+
+func CreateTweetTestGRPC(t *testing.T, className string) {
+	CreateTweetTestWithParamsGRPC(t, className, nil)
+}
+
+func CreateTweetTestWithParamsGRPC(t *testing.T, className string, params *pb.GenerativeProvider) {
+	CreatePromptTestWithParamsGRPC(t, className, "Write a short tweet about planet {name}", "Write a short tweet about the following planets", params)
+}
+
+func CreatePromptTestWithParamsGRPC(t *testing.T, className, singlePrompt, groupPrompt string, params *pb.GenerativeProvider) {
+	var queries []*pb.GenerativeProvider
+	if params != nil {
+		queries = []*pb.GenerativeProvider{params}
+	}
+	req := &pb.SearchRequest{
+		Collection: className,
+		Limit:      2,
+		Generative: &pb.GenerativeSearch{
+			Single: &pb.GenerativeSearch_Single{
+				Prompt:  singlePrompt,
+				Queries: queries,
+			},
+			Grouped: &pb.GenerativeSearch_Grouped{
+				Task:       groupPrompt,
+				Properties: &pb.TextArray{Values: []string{"name"}},
+				Queries:    queries,
+			},
+		},
+		Uses_127Api: true,
+	}
+	resp := grpchelper.AssertSearchWithTimeout(t, req, 10*time.Minute)
+	require.NotNil(t, resp)
+	require.Len(t, resp.Results, 2)
+	for i, res := range resp.Results {
+		assertGenerative(t, res.Generative, params)
+		t.Logf("---------------\n[%v]Single Prompt: %s\n[%v]Result: %s\n---------------\n", i, singlePrompt, i, res.Generative.GetValues()[0].Result)
+	}
+	assertGenerative(t, resp.GenerativeGroupedResults, params)
+	t.Logf("---------------\nGrouped Prompt: %s\nResult: %s\n---------------\n", groupPrompt, resp.GenerativeGroupedResults.GetValues()[0].Result)
+}
+
+func assertGenerative(t *testing.T, generative *pb.GenerativeResult, params *pb.GenerativeProvider) {
+	require.Len(t, generative.GetValues(), 1)
+	require.NotEmpty(t, generative.GetValues()[0].Result)
+	if params.GetReturnMetadata() {
+		metadata := generative.GetValues()[0].GetMetadata()
+		require.NotEmpty(t, metadata)
+		if params.GetAnthropic() != nil {
+			anthropic := metadata.GetAnthropic()
+			require.NotEmpty(t, anthropic)
+			usage := anthropic.GetUsage()
+			require.NotEmpty(t, usage)
+			require.NotEmpty(t, usage.GetInputTokens())
+			require.NotEmpty(t, usage.GetOutputTokens())
+		}
+		if params.GetCohere() != nil {
+			require.NotEmpty(t, metadata.GetCohere())
+		}
+		if params.GetMistral() != nil {
+			require.NotEmpty(t, metadata.GetMistral())
+		}
+		if params.GetOpenai() != nil {
+			require.NotEmpty(t, metadata.GetOpenai())
+		}
+		if params.GetGoogle() != nil {
+			require.NotEmpty(t, metadata.GetGoogle())
+		}
+	}
+}
+
+func GetImageBlob(dataFolderPath, name string) (string, error) {
+	path := fmt.Sprintf("%s/images/%s.jpg", dataFolderPath, name)
+	return helper.GetBase64EncodedData(path)
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-azure/backup_backend_test.go

@@ -0,0 +1,307 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	mod "github.com/weaviate/weaviate/modules/backup-azure"
+	"github.com/weaviate/weaviate/test/docker"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+	ubak "github.com/weaviate/weaviate/usecases/backup"
+)
+
+func Test_AzureBackend_Start(t *testing.T) {
+	tests := []struct {
+		name           string
+		overrideBucket string
+		overridePath   string
+	}{
+		{
+			name:           "default overrides",
+			overrideBucket: "",
+			overridePath:   "",
+		},
+		{
+			name:           "test bucket and path overrides",
+			overrideBucket: "testbucketoverride",
+			overridePath:   "testBucketPathOverride",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testAzureBackendBackup(tt.overrideBucket, tt.overridePath)(t)
+		})
+	}
+}
+
+func testAzureBackendBackup(overrideBucket, overridePath string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		compose, err := docker.New().WithAzurite().Start(ctx)
+		if err != nil {
+			t.Fatalf("cannot start: %v", err)
+		}
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %v", err)
+			}
+		}()
+
+		t.Setenv(envAzureEndpoint, compose.GetAzurite().URI())
+
+		subTests := []struct {
+			name string
+			test func(t *testing.T)
+		}{
+			{
+				name: "store backup meta",
+				test: func(t *testing.T) {
+					moduleLevelStoreBackupMeta(t, overrideBucket, overridePath)
+				},
+			},
+			{
+				name: "copy objects",
+				test: func(t *testing.T) {
+					moduleLevelCopyObjects(t, overrideBucket, overridePath)
+				},
+			},
+			{
+				name: "copy files",
+				test: func(t *testing.T) {
+					moduleLevelCopyFiles(t, overrideBucket, overridePath)
+				},
+			},
+		}
+
+		for _, st := range subTests {
+			t.Run(st.name, st.test)
+		}
+	}
+}
+
+func moduleLevelStoreBackupMeta(t *testing.T, overrideBucket, overridePath string) {
+	testCtx := context.Background()
+
+	className := "BackupClass"
+	backupID := "backup_id"
+	containerName := "container-level-store-backup-meta"
+	if overrideBucket != "" {
+		containerName = overrideBucket
+	}
+	endpoint := os.Getenv(envAzureEndpoint)
+	metadataFilename := "backup.json"
+
+	t.Log("setup env")
+	t.Setenv(envAzureEndpoint, endpoint)
+	t.Setenv(envAzureStorageConnectionString, fmt.Sprintf(connectionString, endpoint))
+	t.Setenv(envAzureContainer, containerName)
+	moduleshelper.CreateAzureContainer(testCtx, t, endpoint, containerName)
+	defer moduleshelper.DeleteAzureContainer(testCtx, t, endpoint, containerName)
+
+	t.Run("store backup meta in Azure", func(t *testing.T) {
+		t.Setenv(envAzureContainer, containerName)
+		azure := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: t.TempDir()})
+		err := azure.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("access permissions", func(t *testing.T) {
+			err := azure.Initialize(testCtx, backupID, overrideBucket, overridePath)
+			assert.Nil(t, err)
+		})
+
+		t.Run("backup meta does not exist yet", func(t *testing.T) {
+			meta, err := azure.GetObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath)
+			assert.Nil(t, meta)
+			assert.NotNil(t, err)
+			assert.IsType(t, backup.ErrNotFound{}, err)
+		})
+
+		t.Run("put backup meta on backend", func(t *testing.T) {
+			desc := &backup.BackupDescriptor{
+				StartedAt:   time.Now(),
+				CompletedAt: time.Time{},
+				ID:          backupID,
+				Classes: []backup.ClassDescriptor{
+					{
+						Name: className,
+					},
+				},
+				Status:  string(backup.Started),
+				Version: ubak.Version,
+			}
+
+			b, err := json.Marshal(desc)
+			require.Nil(t, err)
+
+			err = azure.PutObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath, b)
+			require.Nil(t, err)
+
+			dest := azure.HomeDir(backupID, overrideBucket, overridePath)
+
+			expected := fmt.Sprintf("http://%s/devstoreaccount1/%s/%s", os.Getenv(envAzureEndpoint), containerName, backupID)
+			if overridePath != "" {
+				expected = fmt.Sprintf("http://%s/devstoreaccount1/%s/%s/%s", os.Getenv(envAzureEndpoint), containerName, overridePath, backupID)
+			}
+			assert.Equal(t, expected, dest)
+		})
+
+		t.Run("assert backup meta contents", func(t *testing.T) {
+			obj, err := azure.GetObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath)
+			t.Logf("Error: %+v", err)
+			require.Nil(t, err)
+
+			var meta backup.BackupDescriptor
+			err = json.Unmarshal(obj, &meta)
+			require.Nil(t, err)
+			assert.NotEmpty(t, meta.StartedAt)
+			assert.Empty(t, meta.CompletedAt)
+			assert.Equal(t, meta.Status, string(backup.Started))
+			assert.Empty(t, meta.Error)
+			assert.Len(t, meta.Classes, 1)
+			assert.Equal(t, meta.Classes[0].Name, className)
+			assert.Equal(t, meta.Version, ubak.Version)
+			assert.Nil(t, meta.Classes[0].Error)
+		})
+	})
+}
+
+func moduleLevelCopyObjects(t *testing.T, overrideBucket, overridePath string) {
+	testCtx := context.Background()
+
+	key := "moduleLevelCopyObjects"
+	backupID := "backup_id"
+	containerName := "container-level-copy-objects"
+	if overrideBucket != "" {
+		containerName = overrideBucket
+	}
+	endpoint := os.Getenv(envAzureEndpoint)
+
+	t.Log("setup env")
+	t.Setenv(envAzureEndpoint, endpoint)
+	t.Setenv(envAzureStorageConnectionString, fmt.Sprintf(connectionString, endpoint))
+	t.Setenv(envAzureContainer, containerName)
+	moduleshelper.CreateAzureContainer(testCtx, t, endpoint, containerName)
+	defer moduleshelper.DeleteAzureContainer(testCtx, t, endpoint, containerName)
+
+	t.Run("copy objects", func(t *testing.T) {
+		t.Setenv(envAzureContainer, containerName)
+		azure := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: t.TempDir()})
+		err := azure.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("put object to bucket", func(t *testing.T) {
+			err := azure.PutObject(testCtx, backupID, key, overrideBucket, overridePath, []byte("hello"))
+			t.Logf("Error: %+v", err)
+			assert.Nil(t, err)
+		})
+
+		t.Run("get object from bucket", func(t *testing.T) {
+			meta, err := azure.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			assert.Nil(t, err)
+			assert.Equal(t, []byte("hello"), meta)
+		})
+	})
+}
+
+func moduleLevelCopyFiles(t *testing.T, overrideBucket, overridePath string) {
+	testCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	dataDir := t.TempDir()
+	key := "moduleLevelCopyFiles"
+	backupID := "backup_id"
+	containerName := "container-level-copy-files"
+	if overrideBucket != "" {
+		containerName = overrideBucket
+	}
+	endpoint := os.Getenv(envAzureEndpoint)
+
+	t.Log("setup env")
+	t.Setenv(envAzureEndpoint, endpoint)
+	t.Setenv(envAzureStorageConnectionString, fmt.Sprintf(connectionString, endpoint))
+	t.Logf("Connection string: %s\n", os.Getenv(envAzureStorageConnectionString))
+	t.Setenv(envAzureContainer, containerName)
+	t.Logf("Creating container %s\n", containerName)
+	moduleshelper.CreateAzureContainer(testCtx, t, endpoint, containerName)
+	defer moduleshelper.DeleteAzureContainer(testCtx, t, endpoint, containerName)
+
+	t.Run("copy files", func(t *testing.T) {
+		fpaths := moduleshelper.CreateTestFiles(t, dataDir)
+		fpath := fpaths[0]
+		expectedContents, err := os.ReadFile(fpath)
+		require.Nil(t, err)
+		require.NotNil(t, expectedContents)
+
+		t.Setenv(envAzureContainer, containerName)
+		azure := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: dataDir})
+		err = azure.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("verify source data path", func(t *testing.T) {
+			assert.Equal(t, dataDir, azure.SourceDataPath())
+		})
+
+		t.Run("copy file to backend", func(t *testing.T) {
+			err = azure.PutObject(testCtx, backupID, key, overrideBucket, overridePath, expectedContents)
+			require.Nil(t, err)
+
+			contents, err := azure.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+
+		t.Run("fetch file from backend", func(t *testing.T) {
+			destPath := dataDir + "/file_0.copy.db"
+
+			err := azure.WriteToFile(testCtx, backupID, key, destPath, overrideBucket, overridePath)
+			require.Nil(t, err)
+
+			contents, err := os.ReadFile(destPath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+	})
+}
+
+type fakeStorageProvider struct {
+	dataPath string
+}
+
+func (f *fakeStorageProvider) Storage(name string) (moduletools.Storage, error) {
+	return nil, nil
+}
+
+func (f *fakeStorageProvider) DataPath() string {
+	return f.dataPath
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-azure/backup_journey_test.go

@@ -0,0 +1,89 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/journey"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+)
+
+const (
+	envAzureEndpoint  = "AZURE_ENDPOINT"
+	envAzureContainer = "BACKUP_AZURE_CONTAINER"
+
+	envAzureStorageConnectionString = "AZURE_STORAGE_CONNECTION_STRING"
+	connectionString                = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://%s/devstoreaccount1;"
+
+	azureBackupJourneyClassName = "AzureBackup"
+)
+
+func Test_BackupJourney(t *testing.T) {
+	ctx := context.Background()
+
+	backupJourneyStart(t, ctx, false, "backups", "", "")
+	t.Run("with override bucket and path", func(t *testing.T) {
+		backupJourneyStart(t, ctx, true, "testbucketoverride", "testbucketoverride", "testBucketPathOverride")
+	})
+}
+
+func backupJourneyStart(t *testing.T, ctx context.Context, override bool, containerName, overrideBucket, overridePath string) {
+	azureBackupJourneyBackupIDCluster := "azure-backup-cluster"
+	if override {
+		azureBackupJourneyBackupIDCluster = "azure-backup-cluster-override"
+	}
+
+	t.Run("multiple node", func(t *testing.T) {
+		t.Log("pre-instance env setup")
+		azureBackupJourneyContainerName := "azure-multiple-nodes"
+		t.Setenv(envAzureContainer, azureBackupJourneyContainerName)
+
+		compose, err := docker.New().
+			WithBackendAzure(azureBackupJourneyContainerName).
+			WithText2VecContextionary().
+			WithWeaviateCluster(3).
+			Start(ctx)
+		require.Nil(t, err)
+		defer func() {
+			require.Nil(t, compose.Terminate(ctx))
+		}()
+
+		t.Log("post-instance env setup")
+		azuriteEndpoint := compose.GetAzurite().URI()
+		t.Setenv(envAzureEndpoint, azuriteEndpoint)
+		t.Setenv(envAzureStorageConnectionString, fmt.Sprintf(connectionString, azuriteEndpoint))
+
+		// Create the default container
+		moduleshelper.CreateAzureContainer(ctx, t, azuriteEndpoint, azureBackupJourneyContainerName)
+		defer moduleshelper.DeleteAzureContainer(ctx, t, azuriteEndpoint, azureBackupJourneyContainerName)
+
+		// If using override, create the override container as well
+		if override {
+			moduleshelper.CreateAzureContainer(ctx, t, azuriteEndpoint, overrideBucket)
+			defer moduleshelper.DeleteAzureContainer(ctx, t, azuriteEndpoint, overrideBucket)
+		}
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		t.Run("backup-azure", func(t *testing.T) {
+			journey.BackupJourneyTests_Cluster(t, "azure", azureBackupJourneyClassName,
+				azureBackupJourneyBackupIDCluster, nil, override, overrideBucket, overridePath, compose.GetWeaviate().URI(), compose.GetWeaviateNode(2).URI())
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-azure/multi_tenant_backup_test.go

@@ -0,0 +1,84 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/journey"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+)
+
+const (
+	numTenants = 50
+)
+
+func Test_MultiTenantBackupJourney(t *testing.T) {
+	ctx := context.Background()
+
+	multiTenantBackupJourneyStart(t, ctx, false, "backups", "", "")
+	t.Run("with override bucket and path", func(t *testing.T) {
+		multiTenantBackupJourneyStart(t, ctx, true, "testbucketoverride", "testbucketoverride", "testBucketPathOverride")
+	})
+}
+
+func multiTenantBackupJourneyStart(t *testing.T, ctx context.Context, override bool, containerName, overrideBucket, overridePath string) {
+	azureBackupJourneyBackupIDCluster := "azure-backup-cluster-multi-tenant"
+	if override {
+		azureBackupJourneyBackupIDCluster = "azure-backup-cluster-multi-tenant-override"
+	}
+
+	tenantNames := make([]string, numTenants)
+	for i := range tenantNames {
+		tenantNames[i] = fmt.Sprintf("Tenant%d", i)
+	}
+
+	t.Run("multiple node", func(t *testing.T) {
+		ctx := context.Background()
+		t.Log("pre-instance env setup")
+		containerToUse := containerName
+		if override {
+			containerToUse = overrideBucket
+		}
+		t.Setenv(envAzureContainer, containerToUse)
+
+		compose, err := docker.New().
+			WithBackendAzure(containerToUse).
+			WithText2VecContextionary().
+			WithWeaviateCluster(3).
+			Start(ctx)
+		require.Nil(t, err)
+		defer func() {
+			require.Nil(t, compose.Terminate(ctx))
+		}()
+
+		t.Log("post-instance env setup")
+		azuriteEndpoint := compose.GetAzurite().URI()
+		t.Setenv(envAzureEndpoint, azuriteEndpoint)
+		t.Setenv(envAzureStorageConnectionString, fmt.Sprintf(connectionString, azuriteEndpoint))
+
+		moduleshelper.CreateAzureContainer(ctx, t, azuriteEndpoint, containerToUse)
+		defer moduleshelper.DeleteAzureContainer(ctx, t, azuriteEndpoint, containerToUse)
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		t.Run("backup-azure", func(t *testing.T) {
+			journey.BackupJourneyTests_Cluster(t, "azure", azureBackupJourneyClassName,
+				azureBackupJourneyBackupIDCluster, tenantNames, override, overrideBucket, overridePath, compose.GetWeaviate().URI(), compose.GetWeaviateNode(2).URI())
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-filesystem/backup_backend_test.go

@@ -0,0 +1,214 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	modstgfs "github.com/weaviate/weaviate/modules/backup-filesystem"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+	ubak "github.com/weaviate/weaviate/usecases/backup"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func Test_FileSystemBackend_Start(t *testing.T) {
+	filesystemBackend_Backup(t, "", "", "")
+	filesystemBackend_Backup(t, "", "bucketPath", " with override") // Note:  no bucket parameter, because it is not supported by the filesystem backend
+}
+
+func filesystemBackend_Backup(t *testing.T, overrideBucket, overridePath, overrideDescription string) {
+	t.Run("store backup meta"+overrideDescription, func(t *testing.T) { moduleLevelStoreBackupMeta(t, overrideBucket, overridePath, overrideDescription) })
+	t.Run("copy objects"+overrideDescription, func(t *testing.T) { moduleLevelCopyObjects(t, overrideBucket, overridePath, overrideDescription) })
+	t.Run("copy files"+overrideDescription, func(t *testing.T) { moduleLevelCopyFiles(t, overrideBucket, overridePath, overrideDescription) })
+}
+
+func moduleLevelStoreBackupMeta(t *testing.T, overrideBucket, overridePath, overrideDescription string) {
+	testCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	dataDir := t.TempDir()
+	backupDir := t.TempDir()
+	overrideDir := t.TempDir()
+	if overridePath != "" {
+		overridePath = overrideDir
+	}
+	className := "BackupClass"
+	backupID := "backup_id"
+	metadataFilename := "backup.json"
+
+	t.Setenv("BACKUP_FILESYSTEM_PATH", backupDir)
+
+	t.Run("store backup meta in fs"+overrideDescription, func(t *testing.T) {
+		logger, _ := test.NewNullLogger()
+		sp := fakeStorageProvider{dataDir}
+		params := moduletools.NewInitParams(sp, nil, &config.Config{}, logger, prometheus.NewPedanticRegistry())
+
+		fs := modstgfs.New()
+		err := fs.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("access permissions"+overrideDescription, func(t *testing.T) {
+			err := fs.Initialize(testCtx, backupID, overrideBucket, overridePath)
+			assert.Nil(t, err)
+		})
+
+		t.Run("backup meta does not exist yet"+overrideDescription, func(t *testing.T) {
+			meta, err := fs.GetObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath)
+			assert.Nil(t, meta)
+			assert.NotNil(t, err)
+			assert.IsType(t, backup.ErrNotFound{}, err)
+		})
+
+		t.Run("put backup meta on backend"+overrideDescription, func(t *testing.T) {
+			desc := &backup.BackupDescriptor{
+				StartedAt:   time.Now(),
+				CompletedAt: time.Time{},
+				ID:          backupID,
+				Classes: []backup.ClassDescriptor{
+					{
+						Name: className,
+					},
+				},
+				Status:  string(backup.Started),
+				Version: ubak.Version,
+			}
+
+			b, err := json.Marshal(desc)
+			require.Nil(t, err)
+
+			err = fs.PutObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath, b) // Note:  no bucket parameter, because it is not supported by the filesystem backend
+			require.Nil(t, err)
+
+			dest := fs.HomeDir(backupID, overrideBucket, overridePath)
+			if overridePath == "" {
+				expected := fmt.Sprintf("%s/%s", backupDir, backupID)
+				assert.Equal(t, expected, dest)
+			} else {
+				expected := fmt.Sprintf("%s/%s", overridePath, backupID)
+				assert.Equal(t, expected, dest)
+			}
+		})
+	})
+}
+
+func moduleLevelCopyObjects(t *testing.T, overrideBucket, overridePath, overrideDescription string) {
+	testCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	dataDir := t.TempDir()
+	backupDir := t.TempDir()
+	key := "moduleLevelCopyObjects"
+	backupID := "backup_id"
+
+	t.Setenv("BACKUP_FILESYSTEM_PATH", backupDir)
+
+	t.Run("copy objects"+overrideDescription, func(t *testing.T) {
+		logger, _ := test.NewNullLogger()
+		sp := fakeStorageProvider{dataDir}
+		params := moduletools.NewInitParams(sp, nil, &config.Config{}, logger, prometheus.NewPedanticRegistry())
+
+		fs := modstgfs.New()
+		err := fs.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("put object to bucket"+overrideDescription, func(t *testing.T) {
+			err := fs.PutObject(testCtx, backupID, key, overrideBucket, overridePath, []byte("hello"))
+			assert.Nil(t, err)
+		})
+
+		t.Run("get object from bucket"+overrideDescription, func(t *testing.T) {
+			meta, err := fs.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			assert.Nil(t, err)
+			assert.Equal(t, []byte("hello"), meta)
+		})
+	})
+}
+
+func moduleLevelCopyFiles(t *testing.T, overrideBucket, overridePath, overrideDescription string) {
+	testCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	dataDir := t.TempDir()
+	backupDir := t.TempDir()
+	key := "moduleLevelCopyFiles"
+	backupID := "backup_id"
+
+	t.Setenv("BACKUP_FILESYSTEM_PATH", backupDir)
+
+	t.Run("copy files"+overrideDescription, func(t *testing.T) {
+		fpaths := moduleshelper.CreateTestFiles(t, dataDir)
+		fpath := fpaths[0]
+		expectedContents, err := os.ReadFile(fpath)
+		require.Nil(t, err)
+		require.NotNil(t, expectedContents)
+
+		logger, _ := test.NewNullLogger()
+		sp := fakeStorageProvider{dataDir}
+		params := moduletools.NewInitParams(sp, nil, &config.Config{}, logger, prometheus.NewPedanticRegistry())
+
+		fs := modstgfs.New()
+		err = fs.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("verify source data path"+overrideDescription, func(t *testing.T) {
+			assert.Equal(t, dataDir, fs.SourceDataPath())
+		})
+
+		t.Logf("Source data path: %s\n"+overrideDescription, fs.SourceDataPath())
+
+		t.Run("copy file to backend", func(t *testing.T) {
+			err := fs.PutObject(testCtx, backupID, key, overrideBucket, overridePath, expectedContents)
+			require.Nil(t, err)
+
+			contents, err := fs.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+
+		t.Run("fetch file from backend"+overrideDescription, func(t *testing.T) {
+			destPath := dataDir + "/file_0.copy.db"
+
+			t.Logf("Calling WriteToFile with backupID: %s, key: %s, destPath: %s, override: %s\n", backupID, key, destPath, overrideBucket+"/"+overridePath)
+			err := fs.WriteToFile(testCtx, backupID, key, destPath, overrideBucket, overridePath)
+			t.Logf("Error: %+v", err)
+			require.Nil(t, err)
+
+			contents, err := os.ReadFile(destPath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+	})
+}
+
+type fakeStorageProvider struct {
+	dataPath string
+}
+
+func (sp fakeStorageProvider) Storage(name string) (moduletools.Storage, error) {
+	return nil, nil
+}
+
+func (sp fakeStorageProvider) DataPath() string {
+	return sp.dataPath
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-filesystem/backup_journey_test.go

@@ -0,0 +1,81 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	modstgfilesystem "github.com/weaviate/weaviate/modules/backup-filesystem"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/journey"
+)
+
+const (
+	fsBackupJourneyClassName          = "FileSystemBackup"
+	fsBackupJourneyBackupIDSingleNode = "fs-backup-single-node"
+	fsBackupJourneyBackupIDCluster    = "fs-backup-cluster"
+)
+
+func Test_BackupJourney(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
+	defer cancel()
+
+	t.Run("single node", func(t *testing.T) {
+		compose, err := docker.New().
+			WithBackendFilesystem().
+			WithText2VecContextionary().
+			WithWeaviate().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Run("backup-filesystem", func(t *testing.T) {
+			journey.BackupJourneyTests_SingleNode(t, compose.GetWeaviate().URI(),
+				"filesystem", fsBackupJourneyClassName, fsBackupJourneyBackupIDSingleNode, nil, false, "", "")
+		})
+	})
+
+	t.Run("single node", func(t *testing.T) {
+		compose, err := docker.New().
+			WithBackendFilesystem().
+			WithText2VecContextionary().
+			WithWeaviateEnv("ENABLE_CLEANUP_UNFINISHED_BACKUPS", "true").
+			WithWeaviate().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Run("backup-filesystem", func(t *testing.T) {
+			journey.BackupJourneyTests_SingleNode(t, compose.GetWeaviate().URI(),
+				"filesystem", fsBackupJourneyClassName, fsBackupJourneyBackupIDSingleNode, nil, true, "testbucketoverride", "testBucketPathOverride")
+		})
+
+		t.Run("cancel after restart", func(t *testing.T) {
+			helper.SetupClient(compose.GetWeaviate().URI())
+			journey.CancelFromRestartJourney(t, compose, compose.GetWeaviate().Name(), modstgfilesystem.Name)
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-filesystem/multi_tenant_backup_test.go

@@ -0,0 +1,82 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper/journey"
+)
+
+const numTenants = 50
+
+func Test_MultiTenantBackup(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
+	defer cancel()
+
+	t.Run("single node", func(t *testing.T) {
+		compose, err := docker.New().
+			WithBackendFilesystem().
+			WithText2VecContextionary().
+			WithWeaviate().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Run("backup-filesystem", func(t *testing.T) {
+			tenantNames := make([]string, numTenants)
+			for i := range tenantNames {
+				tenantNames[i] = fmt.Sprintf("Tenant%d", i)
+			}
+
+			journey.BackupJourneyTests_SingleNode(t,
+				compose.GetWeaviate().URI(), "filesystem", fsBackupJourneyClassName,
+				fsBackupJourneyBackupIDSingleNode, tenantNames, false, "", "")
+		})
+	})
+
+	t.Run("single node", func(t *testing.T) {
+		compose, err := docker.New().
+			WithBackendFilesystem().
+			WithText2VecContextionary().
+			WithWeaviate().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Run("backup-filesystem", func(t *testing.T) {
+			tenantNames := make([]string, numTenants)
+			for i := range tenantNames {
+				tenantNames[i] = fmt.Sprintf("Tenant%d", i)
+			}
+
+			journey.BackupJourneyTests_SingleNode(t,
+				compose.GetWeaviate().URI(), "filesystem", fsBackupJourneyClassName,
+				fsBackupJourneyBackupIDSingleNode, tenantNames, true, "testbucketoverride", "testBucketPathOverride")
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-gcs/backup_backend_test.go

@@ -0,0 +1,273 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	mod "github.com/weaviate/weaviate/modules/backup-gcs"
+	"github.com/weaviate/weaviate/test/docker"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+	ubak "github.com/weaviate/weaviate/usecases/backup"
+)
+
+func Test_GcsBackend_Start(t *testing.T) {
+	gCSBackend_Backup(t, "", "")
+
+	gCSBackend_Backup(t, "gcsbetestbucketoverride", "gcsbetestBucketPathOverride")
+}
+
+func gCSBackend_Backup(t *testing.T, overrideBucket, overridePath string) {
+	ctx := context.Background()
+	compose, err := docker.New().WithGCS().Start(ctx)
+	if err != nil {
+		t.Fatal(errors.Wrapf(err, "cannot start"))
+	}
+
+	t.Setenv(envGCSEndpoint, compose.GetGCS().URI())
+
+	t.Run("store backup meta", func(t *testing.T) { moduleLevelStoreBackupMeta(t, overrideBucket, overridePath) })
+	t.Run("copy objects", func(t *testing.T) { moduleLevelCopyObjects(t, overrideBucket, overridePath) })
+	t.Run("copy files", func(t *testing.T) { moduleLevelCopyFiles(t, overrideBucket, overridePath) })
+
+	if err := compose.Terminate(ctx); err != nil {
+		t.Fatal(errors.Wrapf(err, "failed to terminate test containers"))
+	}
+}
+
+func moduleLevelStoreBackupMeta(t *testing.T, overrideBucket, overridePath string) {
+	testCtx := context.Background()
+
+	className := "BackupClass"
+	backupID := "backup_id"
+	bucketName := "bucket-level-store-backup-meta"
+	if overrideBucket != "" {
+		bucketName = overrideBucket
+	}
+	projectID := "project-id"
+	endpoint := os.Getenv(envGCSEndpoint)
+	metadataFilename := "backup.json"
+	gcsUseAuth := "false"
+
+	t.Log("setup env")
+	t.Setenv(envGCSEndpoint, endpoint)
+	t.Setenv(envGCSStorageEmulatorHost, endpoint)
+	t.Setenv(envGCSCredentials, "")
+	t.Setenv(envGCSProjectID, projectID)
+	t.Setenv(envGCSBucket, bucketName)
+	t.Setenv(envGCSUseAuth, gcsUseAuth)
+	moduleshelper.CreateGCSBucket(testCtx, t, projectID, bucketName)
+	defer moduleshelper.DeleteGCSBucket(testCtx, t, bucketName)
+
+	t.Run("store backup meta in gcs", func(t *testing.T) {
+		t.Setenv("BACKUP_GCS_BUCKET", bucketName)
+		gcs := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: t.TempDir()})
+		err := gcs.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("access permissions", func(t *testing.T) {
+			err := gcs.Initialize(testCtx, backupID, overrideBucket, overridePath)
+			assert.Nil(t, err)
+		})
+
+		t.Run("backup meta does not exist yet", func(t *testing.T) {
+			meta, err := gcs.GetObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath)
+			assert.Nil(t, meta)
+			assert.NotNil(t, err)
+			assert.IsType(t, backup.ErrNotFound{}, err)
+		})
+
+		t.Run("put backup meta on backend", func(t *testing.T) {
+			desc := &backup.BackupDescriptor{
+				StartedAt:   time.Now(),
+				CompletedAt: time.Time{},
+				ID:          backupID,
+				Classes: []backup.ClassDescriptor{
+					{
+						Name: className,
+					},
+				},
+				Status:  string(backup.Started),
+				Version: ubak.Version,
+			}
+
+			b, err := json.Marshal(desc)
+			require.Nil(t, err)
+
+			err = gcs.PutObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath, b)
+			require.Nil(t, err)
+
+			dest := gcs.HomeDir(backupID, overrideBucket, overridePath)
+			if overridePath == "" {
+				expected := fmt.Sprintf("gs://%s/%s", bucketName, backupID)
+				assert.Equal(t, expected, dest)
+			} else {
+				expected := fmt.Sprintf("gs://%s/%s/%s", bucketName, overridePath, backupID)
+				assert.Equal(t, expected, dest)
+			}
+		})
+
+		t.Run("assert backup meta contents", func(t *testing.T) {
+			obj, err := gcs.GetObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath)
+			require.Nil(t, err)
+
+			var meta backup.BackupDescriptor
+			err = json.Unmarshal(obj, &meta)
+			require.Nil(t, err)
+			assert.NotEmpty(t, meta.StartedAt)
+			assert.Empty(t, meta.CompletedAt)
+			assert.Equal(t, meta.Status, string(backup.Started))
+			assert.Empty(t, meta.Error)
+			assert.Len(t, meta.Classes, 1)
+			assert.Equal(t, meta.Classes[0].Name, className)
+			assert.Equal(t, meta.Version, ubak.Version)
+			assert.Nil(t, meta.Classes[0].Error)
+		})
+	})
+}
+
+func moduleLevelCopyObjects(t *testing.T, overrideBucket, overridePath string) {
+	testCtx := context.Background()
+
+	key := "moduleLevelCopyObjects"
+	backupID := "backup_id"
+	bucketName := "bucket-level-copy-objects"
+	if overrideBucket != "" {
+		bucketName = overrideBucket
+	}
+	projectID := "project-id"
+	endpoint := os.Getenv(envGCSEndpoint)
+	gcsUseAuth := "false"
+
+	t.Log("setup env")
+	t.Setenv(envGCSEndpoint, endpoint)
+	t.Setenv(envGCSStorageEmulatorHost, endpoint)
+	t.Setenv(envGCSCredentials, "")
+	t.Setenv(envGCSProjectID, projectID)
+	t.Setenv(envGCSBucket, bucketName)
+	t.Setenv(envGCSUseAuth, gcsUseAuth)
+	moduleshelper.CreateGCSBucket(testCtx, t, projectID, bucketName)
+	defer moduleshelper.DeleteGCSBucket(testCtx, t, bucketName)
+
+	t.Run("copy objects", func(t *testing.T) {
+		t.Setenv("BACKUP_GCS_BUCKET", bucketName)
+		gcs := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: t.TempDir()})
+		err := gcs.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("put object to bucket", func(t *testing.T) {
+			err := gcs.PutObject(testCtx, backupID, key, overrideBucket, overridePath, []byte("hello"))
+			assert.Nil(t, err)
+		})
+
+		t.Run("get object from bucket", func(t *testing.T) {
+			meta, err := gcs.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			assert.Nil(t, err)
+			assert.Equal(t, []byte("hello"), meta)
+		})
+	})
+}
+
+func moduleLevelCopyFiles(t *testing.T, overrideBucket, overridePath string) {
+	testCtx := context.Background()
+
+	dataDir := t.TempDir()
+	key := "moduleLevelCopyFiles"
+	backupID := "backup_id"
+	bucketName := "bucket-level-copy-files"
+	if overrideBucket != "" {
+		bucketName = overrideBucket
+	}
+	projectID := "project-id"
+	endpoint := os.Getenv(envGCSEndpoint)
+	gcsUseAuth := "false"
+
+	t.Log("setup env")
+	t.Setenv(envGCSEndpoint, endpoint)
+	t.Setenv(envGCSStorageEmulatorHost, endpoint)
+	t.Setenv(envGCSCredentials, "")
+	t.Setenv(envGCSProjectID, projectID)
+	t.Setenv(envGCSBucket, bucketName)
+	t.Setenv(envGCSUseAuth, gcsUseAuth)
+	moduleshelper.CreateGCSBucket(testCtx, t, projectID, bucketName)
+	defer moduleshelper.DeleteGCSBucket(testCtx, t, bucketName)
+
+	t.Run("copy files", func(t *testing.T) {
+		fpaths := moduleshelper.CreateTestFiles(t, dataDir)
+		fpath := fpaths[0]
+		expectedContents, err := os.ReadFile(fpath)
+		require.Nil(t, err)
+		require.NotNil(t, expectedContents)
+
+		t.Setenv("BACKUP_GCS_BUCKET", bucketName)
+		gcs := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: dataDir})
+		err = gcs.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("verify source data path", func(t *testing.T) {
+			assert.Equal(t, dataDir, gcs.SourceDataPath())
+		})
+
+		t.Run("copy file to backend", func(t *testing.T) {
+			err := gcs.PutObject(testCtx, backupID, key, overrideBucket, overridePath, expectedContents)
+			require.Nil(t, err)
+
+			contents, err := gcs.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+
+		t.Run("fetch file from backend", func(t *testing.T) {
+			destPath := dataDir + "/file_0.copy.db"
+
+			err := gcs.WriteToFile(testCtx, backupID, key, destPath, overrideBucket, overridePath)
+			require.Nil(t, err)
+
+			contents, err := os.ReadFile(destPath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+	})
+}
+
+type fakeStorageProvider struct {
+	dataPath string
+}
+
+func (f *fakeStorageProvider) Storage(name string) (moduletools.Storage, error) {
+	return nil, nil
+}
+
+func (f *fakeStorageProvider) DataPath() string {
+	return f.dataPath
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-gcs/backup_journey_test.go

@@ -0,0 +1,110 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/journey"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+)
+
+const (
+	envGCSEndpoint            = "GCS_ENDPOINT"
+	envGCSStorageEmulatorHost = "STORAGE_EMULATOR_HOST"
+	envGCSCredentials         = "GOOGLE_APPLICATION_CREDENTIALS"
+	envGCSProjectID           = "GOOGLE_CLOUD_PROJECT"
+	envGCSBucket              = "BACKUP_GCS_BUCKET"
+	envGCSUseAuth             = "BACKUP_GCS_USE_AUTH"
+
+	gcsBackupJourneyClassName       = "GcsBackup"
+	gcsBackupJourneyBackupIDCluster = "gcs_backup_cluster"
+	gcsBackupJourneyProjectID       = "gcs_backup_journey"
+)
+
+func Test_BackupJourney(t *testing.T) {
+	tests := []struct {
+		name           string
+		overrideBucket bool
+		bucket         string
+		bucketOverride string
+		pathOverride   string
+	}{
+		{
+			name:           "default backup",
+			overrideBucket: false,
+			bucket:         "backups",
+			bucketOverride: "",
+			pathOverride:   "",
+		},
+		{
+			name:           "with override bucket and path",
+			overrideBucket: true,
+			bucket:         "backups",
+			bucketOverride: "gcsbjtestbucketoverride",
+			pathOverride:   "gcsbjtstBuckPathOveride",
+		},
+	}
+
+	ctx := context.Background()
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			runBackupJourney(t, ctx, tt.overrideBucket, tt.bucket, tt.bucketOverride, tt.pathOverride)
+		})
+	}
+}
+
+func runBackupJourney(t *testing.T, ctx context.Context, override bool, containerName, overrideBucket, overridePath string) {
+	t.Run("multiple node", func(t *testing.T) {
+		ctx := context.Background()
+		t.Log("pre-instance env setup")
+		gcsBackupJourneyBucketName := "gcp-multiple-nodes"
+		t.Setenv(envGCSCredentials, "")
+		t.Setenv(envGCSProjectID, gcsBackupJourneyProjectID)
+		t.Setenv(envGCSBucket, gcsBackupJourneyBucketName)
+
+		compose, err := docker.New().
+			WithBackendGCS(gcsBackupJourneyBucketName).
+			WithText2VecContextionary().
+			WithWeaviateEnv("ENABLE_CLEANUP_UNFINISHED_BACKUPS", "true").
+			WithWeaviateCluster(3).
+			Start(ctx)
+		require.Nil(t, err)
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Log("post-instance env setup")
+		t.Setenv(envGCSEndpoint, compose.GetGCS().URI())
+		t.Setenv(envGCSStorageEmulatorHost, compose.GetGCS().URI())
+		moduleshelper.CreateGCSBucket(ctx, t, gcsBackupJourneyProjectID, gcsBackupJourneyBucketName)
+		if override {
+			moduleshelper.CreateGCSBucket(ctx, t, gcsBackupJourneyProjectID, overrideBucket)
+			defer moduleshelper.DeleteGCSBucket(ctx, t, overrideBucket)
+		}
+		defer moduleshelper.DeleteGCSBucket(ctx, t, gcsBackupJourneyBucketName)
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		t.Run("backup-gcs", func(t *testing.T) {
+			journey.BackupJourneyTests_Cluster(t, "gcs", gcsBackupJourneyClassName,
+				gcsBackupJourneyBackupIDCluster+overrideBucket, nil, override, overrideBucket, overridePath, compose.GetWeaviate().URI(), compose.GetWeaviateNode(2).URI())
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-gcs/multi_tenant_backup_test.go

@@ -0,0 +1,117 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/journey"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+)
+
+const numTenants = 50
+
+func Test_MultiTenantBackupJourney(t *testing.T) {
+	// Set up a context with a 30-minute timeout to manage test duration
+	ctx := context.Background()
+
+	// Define test cases using a table-driven approach
+	tests := []struct {
+		name               string // Name for the subtest
+		override           bool   // Whether to override bucket/path
+		bucket             string // Bucket name
+		overrideBucket     string // Override bucket name (if any)
+		overrideBucketPath string // Override path for bucket (if any)
+	}{
+		{
+			name:               "default backup journey",
+			override:           false,
+			bucket:             "backups",
+			overrideBucket:     "",
+			overrideBucketPath: "",
+		},
+		{
+			name:               "with override bucket and path",
+			override:           true,
+			bucket:             "backups",
+			overrideBucket:     "gcsmbjtestbucketoverride",
+			overrideBucketPath: "testBucketPathOverride",
+		},
+	}
+
+	// Run each test case as a subtest
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Execute the multi-tenant backup journey with the specified parameters
+			multiTenantBackupJourneyStart(
+				t,
+				ctx,
+				tt.override,           // Apply override if true
+				tt.bucket,             // Primary bucket name
+				tt.overrideBucket,     // Override bucket name, if set
+				tt.overrideBucketPath, // Override path, if set
+			)
+		})
+	}
+}
+
+func multiTenantBackupJourneyStart(t *testing.T, ctx context.Context, override bool, containerName, overrideBucket, overridePath string) {
+	tenantNames := make([]string, numTenants)
+	for i := range tenantNames {
+		tenantNames[i] = fmt.Sprintf("Tenant%d", i)
+	}
+
+	t.Run("multiple node", func(t *testing.T) {
+		ctx := context.Background()
+		t.Log("pre-instance env setup")
+		gcsBackupJourneyBucketName := "gcp-multiple-nodes"
+		t.Setenv(envGCSCredentials, "")
+		t.Setenv(envGCSProjectID, gcsBackupJourneyProjectID)
+		t.Setenv(envGCSBucket, gcsBackupJourneyBucketName)
+
+		compose, err := docker.New().
+			WithBackendGCS(gcsBackupJourneyBucketName).
+			WithText2VecContextionary().
+			WithWeaviateCluster(3).
+			Start(ctx)
+		require.Nil(t, err)
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Log("post-instance env setup")
+		t.Setenv(envGCSEndpoint, compose.GetGCS().URI())
+		t.Setenv(envGCSStorageEmulatorHost, compose.GetGCS().URI())
+		moduleshelper.CreateGCSBucket(ctx, t, gcsBackupJourneyProjectID, gcsBackupJourneyBucketName)
+		if override {
+			moduleshelper.CreateGCSBucket(ctx, t, gcsBackupJourneyProjectID, overrideBucket)
+			defer moduleshelper.DeleteGCSBucket(ctx, t, overrideBucket)
+		}
+		defer moduleshelper.DeleteGCSBucket(ctx, t, gcsBackupJourneyBucketName)
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		t.Run("backup-gcs", func(t *testing.T) {
+			journey.BackupJourneyTests_Cluster(t, "gcs", gcsBackupJourneyClassName,
+				gcsBackupJourneyBackupIDCluster+overrideBucket, tenantNames, override, overrideBucket, overridePath,
+				compose.GetWeaviate().URI(), compose.GetWeaviateNode(2).URI())
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-s3/backup_backend_test.go

@@ -0,0 +1,262 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	mod "github.com/weaviate/weaviate/modules/backup-s3"
+	"github.com/weaviate/weaviate/test/docker"
+	moduleshelper "github.com/weaviate/weaviate/test/helper/modules"
+	ubak "github.com/weaviate/weaviate/usecases/backup"
+)
+
+func Test_S3Backend_Start(t *testing.T) {
+	s3Backend_Backup(t, false, "backups", "", "")
+
+	s3Backend_Backup(t, true, "testbucketoverride", "testbucketoverride", "testBucketPathOverride")
+}
+
+func s3Backend_Backup(t *testing.T, override bool, containerName, overrideBucket, overridePath string) {
+	bucketName := containerName
+
+	ctx := context.Background()
+
+	t.Log("setup env")
+	region := "eu-west-1"
+	t.Setenv(envAwsRegion, region)
+	t.Setenv(envS3AccessKey, "aws_access_key")
+	t.Setenv(envS3SecretKey, "aws_secret_key")
+	t.Setenv(envS3Bucket, bucketName)
+
+	t.Logf("Starting test with bucket: %s, %s\n", bucketName, region)
+	compose, err := docker.New().WithBackendS3(bucketName, region).Start(ctx)
+	if err != nil {
+		t.Fatal(errors.Wrapf(err, "cannot start"))
+	}
+
+	t.Setenv(envMinioEndpoint, compose.GetMinIO().URI())
+
+	t.Logf("running tests with bucket %v and path overrides: %v\n", bucketName, override)
+	t.Run("store backup meta",
+		func(t *testing.T) {
+			moduleLevelStoreBackupMeta(t, override, containerName, overrideBucket, overridePath)
+		})
+	t.Run("copy objects", func(t *testing.T) {
+		moduleLevelCopyObjects(t, override, containerName, overrideBucket, overridePath)
+	})
+	t.Run("copy files", func(t *testing.T) {
+		moduleLevelCopyFiles(t, override, containerName, overrideBucket, overridePath)
+	})
+
+	if err := compose.Terminate(ctx); err != nil {
+		t.Fatal(errors.Wrapf(err, "failed to terminate test containers"))
+	}
+}
+
+func moduleLevelStoreBackupMeta(t *testing.T, override bool, containerName, overrideBucket, overridePath string) {
+	testCtx := context.Background()
+
+	bucketName := containerName
+
+	className := "BackupClass"
+	backupID := "backup_id"
+	endpoint := os.Getenv(envMinioEndpoint)
+	metadataFilename := "backup.json"
+
+	t.Logf("storing metadata with override: %v", override)
+
+	t.Run("store backup meta in s3", func(t *testing.T) {
+		t.Setenv(envS3UseSSL, "false")
+		t.Setenv(envS3Endpoint, endpoint)
+		s3 := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: t.TempDir()})
+		err := s3.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("access permissions", func(t *testing.T) {
+			err := s3.Initialize(testCtx, backupID, overrideBucket, overridePath)
+			assert.Nil(t, err)
+		})
+
+		t.Run("backup meta does not exist yet", func(t *testing.T) {
+			meta, err := s3.GetObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath)
+			assert.Nil(t, meta)
+			assert.NotNil(t, err)
+			t.Log(err)
+			assert.IsType(t, backup.ErrNotFound{}, err)
+		})
+
+		t.Run("put backup meta in backend", func(t *testing.T) {
+			desc := &backup.BackupDescriptor{
+				StartedAt:   time.Now(),
+				CompletedAt: time.Time{},
+				ID:          backupID,
+				Classes: []backup.ClassDescriptor{
+					{
+						Name: className,
+					},
+				},
+				Status:  string(backup.Started),
+				Version: ubak.Version,
+			}
+
+			b, err := json.Marshal(desc)
+			require.Nil(t, err)
+
+			err = s3.PutObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath, b)
+			require.Nil(t, err)
+
+			dest := s3.HomeDir(backupID, overrideBucket, overridePath)
+			if overridePath != "" {
+				expected := fmt.Sprintf("s3://%s/%s/%s", overrideBucket, overridePath, backupID)
+				assert.Equal(t, expected, dest)
+			} else {
+				expected := fmt.Sprintf("s3://%s/%s", bucketName, backupID)
+				assert.Equal(t, expected, dest)
+			}
+		})
+
+		t.Run("assert backup meta contents", func(t *testing.T) {
+			obj, err := s3.GetObject(testCtx, backupID, metadataFilename, overrideBucket, overridePath)
+			require.Nil(t, err)
+
+			var meta backup.BackupDescriptor
+			err = json.Unmarshal(obj, &meta)
+			require.Nil(t, err)
+			assert.NotEmpty(t, meta.StartedAt)
+			assert.Empty(t, meta.CompletedAt)
+			assert.Equal(t, meta.Status, string(backup.Started))
+			assert.Empty(t, meta.Error)
+			assert.Len(t, meta.Classes, 1)
+			assert.Equal(t, meta.Classes[0].Name, className)
+			assert.Equal(t, meta.Version, ubak.Version)
+			assert.Nil(t, meta.Classes[0].Error)
+		})
+	})
+}
+
+func moduleLevelCopyObjects(t *testing.T, override bool, containerName, overrideBucket, overridePath string) {
+	testCtx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	key := "moduleLevelCopyObjects"
+	backupID := "backup_id"
+	endpoint := os.Getenv(envMinioEndpoint)
+
+	t.Log("setup env")
+
+	t.Logf("copy objects with override: %v", override)
+
+	t.Run("copy objects", func(t *testing.T) {
+		t.Setenv(envS3UseSSL, "false")
+		t.Setenv(envS3Endpoint, endpoint)
+		s3 := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: t.TempDir()})
+		err := s3.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("put object to bucket", func(t *testing.T) {
+			t.Logf("put object with override: %v", override)
+			err := s3.PutObject(testCtx, backupID, key, overrideBucket, overridePath, []byte("hello"))
+			assert.Nil(t, err, "expected nil, got: %v", err)
+		})
+
+		t.Run("get object from bucket", func(t *testing.T) {
+			t.Logf("get object with override: %v", override)
+			meta, err := s3.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			assert.Nil(t, err, "expected nil, got: %v", err)
+			assert.Equal(t, []byte("hello"), meta)
+		})
+	})
+}
+
+func moduleLevelCopyFiles(t *testing.T, override bool, containerName, overrideBucket, overridePath string) {
+	testCtx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	dataDir := t.TempDir()
+	key := "moduleLevelCopyFiles"
+	backupID := "backup_id"
+	endpoint := os.Getenv(envMinioEndpoint)
+
+	t.Run("copy files", func(t *testing.T) {
+		fpaths := moduleshelper.CreateTestFiles(t, dataDir)
+		fpath := fpaths[0]
+		expectedContents, err := os.ReadFile(fpath)
+		require.Nil(t, err)
+		require.NotNil(t, expectedContents)
+
+		t.Setenv(envS3UseSSL, "false")
+		t.Setenv(envS3Endpoint, endpoint)
+		s3 := mod.New()
+		params := moduletools.NewMockModuleInitParams(t)
+		params.EXPECT().GetLogger().Return(logrus.New())
+		params.EXPECT().GetStorageProvider().Return(&fakeStorageProvider{dataPath: dataDir})
+		err = s3.Init(testCtx, params)
+		require.Nil(t, err)
+
+		t.Run("verify source data path", func(t *testing.T) {
+			t.Log("source data path", s3.SourceDataPath())
+			assert.Equal(t, dataDir, s3.SourceDataPath())
+		})
+
+		t.Run("copy file to backend", func(t *testing.T) {
+			err := s3.PutObject(testCtx, backupID, key, overrideBucket, overridePath, expectedContents)
+			require.Nil(t, err)
+
+			contents, err := s3.GetObject(testCtx, backupID, key, overrideBucket, overridePath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+
+		t.Run("fetch file from backend", func(t *testing.T) {
+			destPath := dataDir + "/file_0.copy.db"
+
+			t.Logf("download file with override: %v", override)
+			err := s3.WriteToFile(testCtx, backupID, key, destPath, overrideBucket, overridePath)
+			require.Nil(t, err)
+
+			contents, err := os.ReadFile(destPath)
+			require.Nil(t, err)
+			assert.Equal(t, expectedContents, contents)
+		})
+	})
+}
+
+type fakeStorageProvider struct {
+	dataPath string
+}
+
+func (f *fakeStorageProvider) Storage(name string) (moduletools.Storage, error) {
+	return nil, nil
+}
+
+func (f *fakeStorageProvider) DataPath() string {
+	return f.dataPath
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-s3/backup_journey_test.go

@@ -0,0 +1,82 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/journey"
+)
+
+const (
+	envMinioEndpoint = "MINIO_ENDPOINT"
+	envAwsRegion     = "AWS_REGION"
+	envS3AccessKey   = "AWS_ACCESS_KEY_ID"
+	envS3SecretKey   = "AWS_SECRET_KEY"
+	envS3Bucket      = "BACKUP_S3_BUCKET"
+	envS3Endpoint    = "BACKUP_S3_ENDPOINT"
+	envS3UseSSL      = "BACKUP_S3_USE_SSL"
+
+	s3BackupJourneyClassName       = "S3Backup"
+	s3BackupJourneyBackupIDCluster = "s3-backup-cluster"
+	s3BackupJourneyRegion          = "eu-west-1"
+	s3BackupJourneyAccessKey       = "aws_access_key"
+	s3BackupJourneySecretKey       = "aws_secret_key"
+)
+
+func Test_BackupJourney(t *testing.T) {
+	ctx := context.Background()
+
+	runBackupJourney(t, ctx, false, "backups", "", "")
+	t.Run("with override bucket and path", func(t *testing.T) {
+		runBackupJourney(t, ctx, true, "testbucketoverride", "testbucketoverride", "testBucketPathOverride")
+	})
+}
+
+func runBackupJourney(t *testing.T, ctx context.Context, override bool, containerName, overrideBucket, overridePath string) {
+	s3BackupJourneyBucketName := containerName
+
+	t.Run("multiple node", func(t *testing.T) {
+		ctx := context.Background()
+
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+		t.Setenv(envS3Bucket, s3BackupJourneyBucketName)
+
+		compose, err := docker.New().
+			WithBackendS3(s3BackupJourneyBucketName, s3BackupJourneyRegion).
+			WithText2VecContextionary().
+			WithWeaviateCluster(3).
+			Start(ctx)
+		require.Nil(t, err)
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Run("post-instance env setup", func(t *testing.T) {
+			helper.SetupClient(compose.GetWeaviate().URI())
+		})
+
+		t.Run("backup-s3", func(t *testing.T) {
+			journey.BackupJourneyTests_Cluster(t, "s3", s3BackupJourneyClassName,
+				s3BackupJourneyBackupIDCluster, nil, override, overrideBucket, overridePath,
+				compose.GetWeaviate().URI(), compose.GetWeaviateNode(2).URI())
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/backup-s3/multi_tenant_backup_test.go

@@ -0,0 +1,74 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/journey"
+)
+
+const numTenants = 50
+
+func Test_MultiTenantBackupJourney(t *testing.T) {
+	ctx := context.Background()
+
+	multiTenantBackupJourneyStart(t, ctx, false, "backups", "", "")
+	t.Run("with override bucket and path", func(t *testing.T) {
+		multiTenantBackupJourneyStart(t, ctx, true, "testbucketoverride", "testbucketoverride", "testBucketPathOverride")
+	})
+}
+
+func multiTenantBackupJourneyStart(t *testing.T, ctx context.Context, override bool, containerName, overrideBucket, overridePath string) {
+	s3BackupJourneyBucketName := containerName
+
+	tenantNames := make([]string, numTenants)
+	for i := range tenantNames {
+		tenantNames[i] = fmt.Sprintf("Tenant%d", i)
+	}
+
+	t.Run("multiple node", func(t *testing.T) {
+		ctx := context.Background()
+
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+		t.Setenv(envS3Bucket, s3BackupJourneyBucketName)
+
+		compose, err := docker.New().
+			WithBackendS3(s3BackupJourneyBucketName, s3BackupJourneyRegion).
+			WithText2VecContextionary().
+			WithWeaviateCluster(3).
+			Start(ctx)
+		require.Nil(t, err)
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		t.Run("post-instance env setup", func(t *testing.T) {
+			helper.SetupClient(compose.GetWeaviate().URI())
+		})
+
+		t.Run("backup-s3", func(t *testing.T) {
+			journey.BackupJourneyTests_Cluster(t, "s3", s3BackupJourneyClassName,
+				s3BackupJourneyBackupIDCluster, tenantNames, override, overrideBucket, overridePath,
+				compose.GetWeaviate().URI(), compose.GetWeaviateNode(2).URI())
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-anthropic/generative_anthropic_test.go

@@ -0,0 +1,204 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeAnthropic(rest, grpc string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Define path to test/helper/sample-schema/planets/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/planets/data"
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-transformers": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name               string
+			generativeModel    string
+			absentModuleConfig bool
+			withImages         bool
+		}{
+			{
+				name:            "claude-3-5-sonnet-20240620",
+				generativeModel: "claude-3-5-sonnet-20240620",
+			},
+			{
+				name:            "claude-3-opus-20240229",
+				generativeModel: "claude-3-opus-20240229",
+			},
+			{
+				name:            "claude-3-sonnet-20240229",
+				generativeModel: "claude-3-sonnet-20240229",
+			},
+			{
+				name:            "claude-3-haiku-20240307",
+				generativeModel: "claude-3-haiku-20240307",
+			},
+			{
+				name:               "absent module config",
+				generativeModel:    "claude-3-5-sonnet-20240620",
+				absentModuleConfig: true,
+			},
+			{
+				name:            "claude-3-5-sonnet-20241022",
+				generativeModel: "claude-3-5-sonnet-20241022",
+				withImages:      true,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				if tt.absentModuleConfig {
+					t.Log("skipping adding module config configuration to class")
+				} else {
+					class.ModuleConfig = map[string]interface{}{
+						"generative-anthropic": map[string]interface{}{
+							"model": tt.generativeModel,
+						},
+					}
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					if tt.withImages {
+						planets.InsertObjectsWithImages(t, class.Class, dataFolderPath)
+					} else {
+						planets.InsertObjects(t, class.Class)
+					}
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range data {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				t.Run("create a tweet", func(t *testing.T) {
+					planets.CreateTweetTest(t, class.Class)
+				})
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := fmt.Sprintf("anthropic:{topP:0.9 topK:90 model:%q}", tt.generativeModel)
+					if tt.absentModuleConfig {
+						params = fmt.Sprintf("anthropic:{topP:0.9 topK:90 model:%q baseURL:\"%s\"}", tt.generativeModel, "https://api.anthropic.com")
+					}
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+				t.Run("create a tweet using grpc", func(t *testing.T) {
+					planets.CreateTweetTestGRPC(t, class.Class)
+				})
+
+				params := func() *pb.GenerativeAnthropic {
+					params := &pb.GenerativeAnthropic{
+						MaxTokens:     grpchelper.ToPtr(int64(90)),
+						Model:         grpchelper.ToPtr(tt.generativeModel),
+						Temperature:   grpchelper.ToPtr(0.9),
+						TopK:          grpchelper.ToPtr(int64(90)),
+						TopP:          grpchelper.ToPtr(0.9),
+						StopSequences: &pb.TextArray{Values: []string{"stop"}},
+					}
+					if tt.absentModuleConfig {
+						params.BaseUrl = grpchelper.ToPtr("https://api.anthropic.com")
+					}
+					return params
+				}
+
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{
+						ReturnMetadata: true,
+						Kind:           &pb.GenerativeProvider_Anthropic{Anthropic: params()},
+					})
+				})
+				if tt.withImages {
+					t.Run("image prompt", func(t *testing.T) {
+						t.Run("graphql", func(t *testing.T) {
+							prompt := "Describe image"
+							params := "anthropic:{imageProperties:\"image\"}"
+							planets.CreatePromptTestWithParams(t, class.Class, prompt, params)
+						})
+
+						singlePrompt := "Give a short answer: What's on the image?"
+						groupPrompt := "Give a short answer: What are on the following images?"
+
+						t.Run("grpc server stored images", func(t *testing.T) {
+							params := params()
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Anthropic{Anthropic: params},
+							})
+						})
+
+						t.Run("grpc user provided images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Anthropic{Anthropic: params},
+							})
+						})
+
+						t.Run("grpc mixed images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Anthropic{Anthropic: params},
+							})
+						})
+					})
+				}
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-anthropic/setup_test.go

@@ -0,0 +1,54 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeAnthropic_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("ANTHROPIC_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, ANTHROPIC_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+
+	t.Run("tests", testGenerativeAnthropic(endpointREST, endpointGRPC))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviateWithGRPC().
+		WithWeaviateEnv("MODULES_CLIENT_TIMEOUT", "120s").
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeAnthropic(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-aws/generative_aws_test.go

@@ -0,0 +1,255 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeAWS(rest, grpc, region string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Define path to test/helper/sample-schema/planets/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/planets/data"
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-aws": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+						"service":            "bedrock",
+						"region":             region,
+						"model":              "amazon.titan-embed-text-v2:0",
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name               string
+			generativeModel    string
+			absentModuleConfig bool
+			withImages         bool
+		}{
+			// Amazon Titan
+			{
+				name:            "amazon.titan-text-lite-v1",
+				generativeModel: "amazon.titan-text-lite-v1",
+			},
+			{
+				name:            "amazon.titan-text-express-v1",
+				generativeModel: "amazon.titan-text-express-v1",
+			},
+			{
+				name:            "amazon.titan-text-premier-v1:0",
+				generativeModel: "amazon.titan-text-premier-v1:0",
+			},
+			// Anthropic
+			{
+				name:            "anthropic.claude-3-sonnet-20240229-v1:0",
+				generativeModel: "anthropic.claude-3-sonnet-20240229-v1:0",
+			},
+			{
+				name:            "anthropic.claude-3-haiku-20240307-v1:0",
+				generativeModel: "anthropic.claude-3-haiku-20240307-v1:0",
+				withImages:      true,
+			},
+			{
+				name:            "anthropic.claude-v2:1",
+				generativeModel: "anthropic.claude-v2:1",
+			},
+			{
+				name:            "anthropic.claude-v2",
+				generativeModel: "anthropic.claude-v2",
+			},
+			{
+				name:            "anthropic.claude-instant-v1",
+				generativeModel: "anthropic.claude-instant-v1",
+			},
+			// Cohere
+			{
+				name:            "cohere.command-r-v1:0",
+				generativeModel: "cohere.command-r-v1:0",
+			},
+			{
+				name:            "cohere.command-r-plus-v1:0",
+				generativeModel: "cohere.command-r-plus-v1:0",
+			},
+			// Meta
+			{
+				name:            "meta.llama3-8b-instruct-v1:0",
+				generativeModel: "meta.llama3-8b-instruct-v1:0",
+			},
+			{
+				name:            "meta.llama3-70b-instruct-v1:0",
+				generativeModel: "meta.llama3-70b-instruct-v1:0",
+			},
+			{
+				name:               "absent module config",
+				generativeModel:    "meta.llama3-70b-instruct-v1:0",
+				absentModuleConfig: true,
+			},
+			// Mistral AI
+			{
+				name:            "mistral.mistral-7b-instruct-v0:2",
+				generativeModel: "mistral.mistral-7b-instruct-v0:2",
+			},
+			{
+				name:            "mistral.mixtral-8x7b-instruct-v0:1",
+				generativeModel: "mistral.mixtral-8x7b-instruct-v0:1",
+			},
+			{
+				name:            "mistral.mistral-large-2402-v1:0",
+				generativeModel: "mistral.mistral-large-2402-v1:0",
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				if tt.absentModuleConfig {
+					t.Log("skipping adding module config configuration to class")
+				} else {
+					class.ModuleConfig = map[string]interface{}{
+						"generative-aws": map[string]interface{}{
+							"service": "bedrock",
+							"region":  region,
+							"model":   tt.generativeModel,
+						},
+					}
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					if tt.withImages {
+						planets.InsertObjectsWithImages(t, class.Class, dataFolderPath)
+					} else {
+						planets.InsertObjects(t, class.Class)
+					}
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range data {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				if tt.absentModuleConfig {
+					t.Log("skipping create tweet tests with default values as e2e tests rely on specific AWS settings")
+				} else {
+					t.Run("create a tweet", func(t *testing.T) {
+						planets.CreateTweetTest(t, class.Class)
+					})
+					t.Run("create a tweet using grpc", func(t *testing.T) {
+						planets.CreateTweetTestGRPC(t, class.Class)
+					})
+				}
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := "aws:{temperature:0.1}"
+					if tt.absentModuleConfig {
+						params = fmt.Sprintf("aws:{temperature:0.1 service:\"bedrock\" region:\"%s\" model:\"%s\"}", region, tt.generativeModel)
+					}
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+
+				params := func() *pb.GenerativeAWS {
+					params := &pb.GenerativeAWS{
+						Model:       grpchelper.ToPtr(tt.generativeModel),
+						Temperature: grpchelper.ToPtr(0.9),
+					}
+					if tt.absentModuleConfig {
+						params.Region = grpchelper.ToPtr(region)
+						params.Service = grpchelper.ToPtr("bedrock")
+					}
+					return params
+				}
+
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{
+						ReturnMetadata: false, // no metadata for aws
+						Kind:           &pb.GenerativeProvider_Aws{Aws: params()},
+					})
+				})
+				if tt.withImages {
+					t.Run("image prompt", func(t *testing.T) {
+						t.Run("graphql", func(t *testing.T) {
+							prompt := "Caption image"
+							params := "aws:{imageProperties:\"image\"}"
+							planets.CreatePromptTestWithParams(t, class.Class, prompt, params)
+						})
+
+						singlePrompt := "Give a short answer: What's on the image?"
+						groupPrompt := "Give a short answer: What are on the following images?"
+
+						t.Run("grpc server stored images", func(t *testing.T) {
+							params := params()
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: false,
+								Kind:           &pb.GenerativeProvider_Aws{Aws: params},
+							})
+						})
+
+						t.Run("grpc user provided images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: false,
+								Kind:           &pb.GenerativeProvider_Aws{Aws: params},
+							})
+						})
+
+						t.Run("grpc mixed images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: false,
+								Kind:           &pb.GenerativeProvider_Aws{Aws: params},
+							})
+						})
+					})
+				}
+			})
+		}
+	}
+}