feat: add VectorStore service layer with types and connection testing
Add VectorStoreService with CRUD validation, duplicate checking (DB + env stores), and engine-specific health checks for 6 vector database types. Include VectorStoreResponse DTO, env store builder, engine type metadata, and comprehensive unit tests.
This commit is contained in:
@@ -59,6 +59,15 @@ func (r *vectorStoreRepository) Update(ctx context.Context, store *types.VectorS
|
||||
).Select("name").Updates(store).Error
|
||||
}
|
||||
|
||||
// UpdateConnectionConfig updates only the connection_config JSONB column.
|
||||
// Used for saving auto-detected metadata (e.g., server version) without
|
||||
// touching user-immutable fields like engine_type or index_config.
|
||||
func (r *vectorStoreRepository) UpdateConnectionConfig(ctx context.Context, store *types.VectorStore) error {
|
||||
return r.db.WithContext(ctx).Model(&types.VectorStore{}).Where(
|
||||
"id = ? AND tenant_id = ?", store.ID, store.TenantID,
|
||||
).Select("connection_config").Updates(store).Error
|
||||
}
|
||||
|
||||
// Delete soft-deletes a vector store
|
||||
func (r *vectorStoreRepository) Delete(ctx context.Context, tenantID uint64, id string) error {
|
||||
return r.db.WithContext(ctx).Where(
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/errors"
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
secutils "github.com/Tencent/WeKnora/internal/utils"
|
||||
)
|
||||
|
||||
// vectorStoreService implements interfaces.VectorStoreService
|
||||
type vectorStoreService struct {
|
||||
repo interfaces.VectorStoreRepository
|
||||
}
|
||||
|
||||
// NewVectorStoreService creates a new vector store service
|
||||
func NewVectorStoreService(
|
||||
repo interfaces.VectorStoreRepository,
|
||||
) interfaces.VectorStoreService {
|
||||
return &vectorStoreService{repo: repo}
|
||||
}
|
||||
|
||||
// CreateStore validates and creates a new vector store.
|
||||
func (s *vectorStoreService) CreateStore(ctx context.Context, store *types.VectorStore) error {
|
||||
// 1. Basic validation (name, engine_type, tenant_id)
|
||||
if err := store.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// 2. Engine-specific connection config validation
|
||||
if err := validateConnectionConfig(store.EngineType, store.ConnectionConfig); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// 3. Duplicate check — DB stores
|
||||
endpoint := store.ConnectionConfig.GetEndpoint()
|
||||
indexName := store.IndexConfig.GetIndexNameOrDefault(store.EngineType)
|
||||
|
||||
exists, err := s.repo.ExistsByEndpointAndIndex(ctx, store.TenantID, store.EngineType, endpoint, indexName)
|
||||
if err != nil {
|
||||
return errors.NewInternalServerError("failed to check for duplicates")
|
||||
}
|
||||
if exists {
|
||||
return errors.NewConflictError("a vector store with the same endpoint and index already exists")
|
||||
}
|
||||
|
||||
// 4. Duplicate check — env stores (pure function, no os.Getenv in types)
|
||||
for _, envStore := range types.BuildEnvVectorStores(os.Getenv("RETRIEVE_DRIVER"), os.Getenv) {
|
||||
if envStore.EngineType == store.EngineType &&
|
||||
envStore.ConnectionConfig.GetEndpoint() == endpoint &&
|
||||
envStore.IndexConfig.GetIndexNameOrDefault(store.EngineType) == indexName {
|
||||
return errors.NewConflictError(
|
||||
"a vector store with the same endpoint and index is already configured via environment variables")
|
||||
}
|
||||
}
|
||||
|
||||
// 5. Persist
|
||||
logger.Infof(ctx, "Creating vector store: tenant=%d, name=%s, engine=%s",
|
||||
store.TenantID, secutils.SanitizeForLog(store.Name), store.EngineType)
|
||||
return s.repo.Create(ctx, store)
|
||||
}
|
||||
|
||||
// UpdateStore updates an existing vector store (name only).
|
||||
func (s *vectorStoreService) UpdateStore(ctx context.Context, store *types.VectorStore) error {
|
||||
if store.TenantID == 0 {
|
||||
return errors.NewValidationError("tenant_id is required")
|
||||
}
|
||||
if store.Name == "" {
|
||||
return errors.NewValidationError("name is required")
|
||||
}
|
||||
|
||||
logger.Infof(ctx, "Updating vector store: tenant=%d, id=%s", store.TenantID, store.ID)
|
||||
return s.repo.Update(ctx, store)
|
||||
}
|
||||
|
||||
// DeleteStore deletes a vector store by tenant + id.
|
||||
// Phase 2: KB binding check will be added here.
|
||||
func (s *vectorStoreService) DeleteStore(ctx context.Context, tenantID uint64, id string) error {
|
||||
logger.Infof(ctx, "Deleting vector store: tenant=%d, id=%s", tenantID, id)
|
||||
return s.repo.Delete(ctx, tenantID, id)
|
||||
}
|
||||
|
||||
// SaveDetectedVersion updates the connection_config.version for a stored vector store.
|
||||
// Works on a copy to avoid mutating the caller's object.
|
||||
func (s *vectorStoreService) SaveDetectedVersion(ctx context.Context, store *types.VectorStore, version string) error {
|
||||
updated := *store
|
||||
updated.ConnectionConfig.Version = version
|
||||
return s.repo.UpdateConnectionConfig(ctx, &updated)
|
||||
}
|
||||
|
||||
// validateConnectionConfig validates required fields per engine type.
|
||||
func validateConnectionConfig(engineType types.RetrieverEngineType, config types.ConnectionConfig) error {
|
||||
switch engineType {
|
||||
case types.ElasticsearchRetrieverEngineType:
|
||||
if config.Addr == "" {
|
||||
return errors.NewValidationError("addr is required for elasticsearch")
|
||||
}
|
||||
case types.PostgresRetrieverEngineType:
|
||||
if !config.UseDefaultConnection && config.Addr == "" {
|
||||
return errors.NewValidationError("addr or use_default_connection is required for postgres")
|
||||
}
|
||||
case types.QdrantRetrieverEngineType:
|
||||
if config.Host == "" {
|
||||
return errors.NewValidationError("host is required for qdrant")
|
||||
}
|
||||
case types.MilvusRetrieverEngineType:
|
||||
if config.Addr == "" {
|
||||
return errors.NewValidationError("addr is required for milvus")
|
||||
}
|
||||
case types.WeaviateRetrieverEngineType:
|
||||
if config.Host == "" {
|
||||
return errors.NewValidationError("host is required for weaviate")
|
||||
}
|
||||
case types.SQLiteRetrieverEngineType:
|
||||
// No connection config needed for SQLite
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/errors"
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
_ "github.com/jackc/pgx/v5/stdlib" // pgx driver for database/sql
|
||||
"github.com/qdrant/go-client/qdrant"
|
||||
"github.com/weaviate/weaviate-go-client/v5/weaviate"
|
||||
"github.com/weaviate/weaviate-go-client/v5/weaviate/auth"
|
||||
wgrpc "github.com/weaviate/weaviate-go-client/v5/weaviate/grpc"
|
||||
)
|
||||
|
||||
const connectionTestTimeout = 10 * time.Second
|
||||
|
||||
// TestConnection tests connectivity to a vector database.
|
||||
// Returns the detected server version on success (e.g., "7.10.1"), empty string if unknown.
|
||||
func (s *vectorStoreService) TestConnection(
|
||||
ctx context.Context,
|
||||
engineType types.RetrieverEngineType,
|
||||
config types.ConnectionConfig,
|
||||
) (string, error) {
|
||||
switch engineType {
|
||||
case types.ElasticsearchRetrieverEngineType:
|
||||
return testElasticsearchConnection(ctx, config)
|
||||
case types.PostgresRetrieverEngineType:
|
||||
return testPostgresConnection(ctx, config)
|
||||
case types.QdrantRetrieverEngineType:
|
||||
return testQdrantConnection(ctx, config)
|
||||
case types.MilvusRetrieverEngineType:
|
||||
return testMilvusConnection(ctx, config)
|
||||
case types.WeaviateRetrieverEngineType:
|
||||
return testWeaviateConnection(ctx, config)
|
||||
case types.SQLiteRetrieverEngineType:
|
||||
// SQLite is file-based, no remote connection to test
|
||||
return "", nil
|
||||
default:
|
||||
return "", errors.NewBadRequestError(
|
||||
fmt.Sprintf("connection test not supported for engine type: %s", engineType))
|
||||
}
|
||||
}
|
||||
|
||||
func testElasticsearchConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
// Use plain HTTP GET to the root endpoint instead of the go-elasticsearch SDK.
|
||||
// The v8 SDK's TypedClient performs a product check that rejects ES7 servers,
|
||||
// so we use a raw HTTP request to support both v7 and v8.
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, config.Addr, nil)
|
||||
if err != nil {
|
||||
return "", errors.NewBadRequestError("failed to create elasticsearch request: invalid address")
|
||||
}
|
||||
if config.Username != "" {
|
||||
req.SetBasicAuth(config.Username, config.Password)
|
||||
}
|
||||
|
||||
client := &http.Client{Timeout: connectionTestTimeout}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Elasticsearch connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to elasticsearch: connection refused or authentication failed")
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
logger.Warnf(ctx, "Elasticsearch connection test returned status %d", resp.StatusCode)
|
||||
return "", errors.NewBadRequestError("failed to connect to elasticsearch: authentication failed or server error")
|
||||
}
|
||||
|
||||
// Parse version from response: {"version": {"number": "7.10.1"}, ...}
|
||||
body, err := io.ReadAll(io.LimitReader(resp.Body, 4096))
|
||||
if err != nil {
|
||||
return "", nil // connected but version unknown
|
||||
}
|
||||
|
||||
var esInfo struct {
|
||||
Version struct {
|
||||
Number string `json:"number"`
|
||||
} `json:"version"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &esInfo); err != nil {
|
||||
return "", nil // connected but version unparseable
|
||||
}
|
||||
|
||||
return esInfo.Version.Number, nil
|
||||
}
|
||||
|
||||
func testPostgresConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
if config.UseDefaultConnection {
|
||||
// Using the default app DB connection — always reachable if the app is running.
|
||||
// Cannot query version without a DB handle; return empty.
|
||||
return "", nil
|
||||
}
|
||||
|
||||
db, err := sql.Open("pgx", config.Addr)
|
||||
if err != nil {
|
||||
return "", errors.NewBadRequestError("failed to create postgres connection: invalid configuration")
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
if err := db.PingContext(testCtx); err != nil {
|
||||
logger.Warnf(ctx, "Postgres connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to postgres: connection refused or authentication failed")
|
||||
}
|
||||
|
||||
// Detect version
|
||||
var version string
|
||||
if err := db.QueryRowContext(testCtx, "SHOW server_version").Scan(&version); err != nil {
|
||||
logger.Warnf(ctx, "Postgres version detection failed: %v", err)
|
||||
return "", nil // connected but version unknown
|
||||
}
|
||||
|
||||
return version, nil
|
||||
}
|
||||
|
||||
func testQdrantConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
port := config.Port
|
||||
if port == 0 {
|
||||
port = 6334
|
||||
}
|
||||
|
||||
client, err := qdrant.NewClient(&qdrant.Config{
|
||||
Host: config.Host,
|
||||
Port: port,
|
||||
APIKey: config.APIKey,
|
||||
UseTLS: config.UseTLS,
|
||||
})
|
||||
if err != nil {
|
||||
return "", errors.NewBadRequestError("failed to create qdrant client: invalid configuration")
|
||||
}
|
||||
defer client.Close()
|
||||
|
||||
result, err := client.HealthCheck(testCtx)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Qdrant connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to qdrant: connection refused or authentication failed")
|
||||
}
|
||||
|
||||
return result.GetVersion(), nil
|
||||
}
|
||||
|
||||
func testMilvusConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
// Use TCP dial instead of the Milvus SDK to avoid protobuf namespace conflict
|
||||
// between milvus-proto and qdrant-client (both register "common.proto").
|
||||
// A TCP dial is sufficient for connectivity verification; the Milvus SDK client
|
||||
// creation in container.go (PR 3) will validate full gRPC connectivity.
|
||||
// Version detection is not possible with TCP dial alone.
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
addr := config.Addr
|
||||
if addr == "" {
|
||||
addr = "localhost:19530"
|
||||
}
|
||||
|
||||
conn, err := (&net.Dialer{}).DialContext(testCtx, "tcp", addr)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Milvus connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to milvus: connection refused or server unreachable")
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
return "", nil
|
||||
}
|
||||
|
||||
func testWeaviateConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
host := config.Host
|
||||
if host == "" {
|
||||
host = "weaviate:8080"
|
||||
}
|
||||
grpcAddress := config.GrpcAddress
|
||||
if grpcAddress == "" {
|
||||
grpcAddress = "weaviate:50051"
|
||||
}
|
||||
scheme := config.Scheme
|
||||
if scheme == "" {
|
||||
scheme = "http"
|
||||
}
|
||||
|
||||
weaviateCfg := weaviate.Config{
|
||||
Host: host,
|
||||
GrpcConfig: &wgrpc.Config{
|
||||
Host: grpcAddress,
|
||||
},
|
||||
Scheme: scheme,
|
||||
}
|
||||
if config.APIKey != "" {
|
||||
weaviateCfg.AuthConfig = auth.ApiKey{Value: config.APIKey}
|
||||
}
|
||||
|
||||
// Weaviate Go client v5 does not expose a Close() method;
|
||||
// it uses HTTP + gRPC transports that are managed internally.
|
||||
client, err := weaviate.NewClient(weaviateCfg)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Weaviate connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to create weaviate client: invalid configuration")
|
||||
}
|
||||
|
||||
isReady, err := client.Misc().ReadyChecker().Do(testCtx)
|
||||
if err != nil || !isReady {
|
||||
logger.Warnf(ctx, "Weaviate connection test failed: ready=%v, err=%v", isReady, err)
|
||||
return "", errors.NewBadRequestError("failed to connect to weaviate: server not ready or authentication failed")
|
||||
}
|
||||
|
||||
// Detect version via /v1/meta
|
||||
meta, err := client.Misc().MetaGetter().Do(testCtx)
|
||||
if err != nil || meta == nil {
|
||||
return "", nil // connected but version unknown
|
||||
}
|
||||
|
||||
return meta.Version, nil
|
||||
}
|
||||
@@ -0,0 +1,525 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/errors"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Mock repository
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
type mockVectorStoreRepo struct {
|
||||
stores []*types.VectorStore
|
||||
createErr error
|
||||
updateErr error
|
||||
deleteErr error
|
||||
existsByEndpointErr error
|
||||
existsByEndpoint bool
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) Create(_ context.Context, store *types.VectorStore) error {
|
||||
if m.createErr != nil {
|
||||
return m.createErr
|
||||
}
|
||||
m.stores = append(m.stores, store)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) GetByID(_ context.Context, tenantID uint64, id string) (*types.VectorStore, error) {
|
||||
for _, s := range m.stores {
|
||||
if s.ID == id && s.TenantID == tenantID {
|
||||
return s, nil
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) List(_ context.Context, tenantID uint64) ([]*types.VectorStore, error) {
|
||||
var result []*types.VectorStore
|
||||
for _, s := range m.stores {
|
||||
if s.TenantID == tenantID {
|
||||
result = append(result, s)
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) Update(_ context.Context, store *types.VectorStore) error {
|
||||
return m.updateErr
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) UpdateConnectionConfig(_ context.Context, _ *types.VectorStore) error {
|
||||
return m.updateErr
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) Delete(_ context.Context, _ uint64, _ string) error {
|
||||
return m.deleteErr
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) ExistsByEndpointAndIndex(
|
||||
_ context.Context, _ uint64, _ types.RetrieverEngineType, _ string, _ string,
|
||||
) (bool, error) {
|
||||
if m.existsByEndpointErr != nil {
|
||||
return false, m.existsByEndpointErr
|
||||
}
|
||||
return m.existsByEndpoint, nil
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CreateStore tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestCreateStore_Success(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "test-es",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, repo.stores, 1)
|
||||
}
|
||||
|
||||
func TestCreateStore_ValidationError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
store *types.VectorStore
|
||||
}{
|
||||
{
|
||||
name: "empty name",
|
||||
store: &types.VectorStore{TenantID: 1, EngineType: types.PostgresRetrieverEngineType},
|
||||
},
|
||||
{
|
||||
name: "invalid engine type",
|
||||
store: &types.VectorStore{TenantID: 1, Name: "test", EngineType: "unknown"},
|
||||
},
|
||||
{
|
||||
name: "zero tenant ID",
|
||||
store: &types.VectorStore{Name: "test", EngineType: types.PostgresRetrieverEngineType},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := svc.CreateStore(context.Background(), tt.store)
|
||||
require.Error(t, err)
|
||||
var appErr *errors.AppError
|
||||
assert.ErrorAs(t, err, &appErr)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateStore_ConnectionConfigValidation(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
store *types.VectorStore
|
||||
wantError bool
|
||||
}{
|
||||
{
|
||||
name: "elasticsearch without addr",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "postgres without addr or default connection",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.PostgresRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "postgres with use_default_connection",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.PostgresRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{UseDefaultConnection: true},
|
||||
},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "qdrant without host",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.QdrantRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "milvus without addr",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.MilvusRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "weaviate without host",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.WeaviateRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "sqlite with no config (ok)",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.SQLiteRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := svc.CreateStore(context.Background(), tt.store)
|
||||
if tt.wantError {
|
||||
require.Error(t, err)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_DBStore(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: true}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "dup-store",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
require.Error(t, err)
|
||||
|
||||
var appErr *errors.AppError
|
||||
require.ErrorAs(t, err, &appErr)
|
||||
assert.Equal(t, errors.ErrConflict, appErr.Code)
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_DBError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{
|
||||
existsByEndpointErr: assert.AnError,
|
||||
}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "test",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
require.Error(t, err)
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_EnvStore(t *testing.T) {
|
||||
// Set up env to simulate an existing elasticsearch env store
|
||||
t.Setenv("RETRIEVE_DRIVER", "elasticsearch_v8")
|
||||
t.Setenv("ELASTICSEARCH_ADDR", "http://es:9200")
|
||||
t.Setenv("ELASTICSEARCH_USERNAME", "elastic")
|
||||
t.Setenv("ELASTICSEARCH_PASSWORD", "secret")
|
||||
t.Setenv("ELASTICSEARCH_INDEX", "xwrag_default")
|
||||
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: false} // no DB duplicate
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "dup-env-store",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
IndexConfig: types.IndexConfig{
|
||||
IndexName: "xwrag_default",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
require.Error(t, err)
|
||||
|
||||
var appErr *errors.AppError
|
||||
require.ErrorAs(t, err, &appErr)
|
||||
assert.Equal(t, errors.ErrConflict, appErr.Code)
|
||||
assert.Contains(t, appErr.Error(), "environment variables")
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_EnvStore_DifferentIndex_Allowed(t *testing.T) {
|
||||
// Same endpoint as env store but different index — should be allowed
|
||||
t.Setenv("RETRIEVE_DRIVER", "elasticsearch_v8")
|
||||
t.Setenv("ELASTICSEARCH_ADDR", "http://es:9200")
|
||||
t.Setenv("ELASTICSEARCH_INDEX", "xwrag_default")
|
||||
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: false}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "different-index",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
IndexConfig: types.IndexConfig{
|
||||
IndexName: "different_index",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestCreateStore_DifferentEndpointSameIndex_Allowed(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: false}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "new-store",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es-new:9200",
|
||||
},
|
||||
IndexConfig: types.IndexConfig{
|
||||
IndexName: "shared_index",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// UpdateStore tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestUpdateStore_Success(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
ID: "test-id",
|
||||
TenantID: 1,
|
||||
Name: "updated-name",
|
||||
}
|
||||
|
||||
err := svc.UpdateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestUpdateStore_ValidationError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
store *types.VectorStore
|
||||
}{
|
||||
{
|
||||
name: "empty name",
|
||||
store: &types.VectorStore{ID: "id", TenantID: 1, Name: ""},
|
||||
},
|
||||
{
|
||||
name: "zero tenant ID",
|
||||
store: &types.VectorStore{ID: "id", TenantID: 0, Name: "test"},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := svc.UpdateStore(context.Background(), tt.store)
|
||||
require.Error(t, err)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// DeleteStore tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestDeleteStore_Success(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
err := svc.DeleteStore(context.Background(), 1, "test-id")
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestDeleteStore_RepoError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{deleteErr: assert.AnError}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
err := svc.DeleteStore(context.Background(), 1, "test-id")
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// TestConnection tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestTestConnection_UnsupportedEngineType(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
_, err := svc.TestConnection(context.Background(), "unknown_engine", types.ConnectionConfig{})
|
||||
require.Error(t, err)
|
||||
|
||||
var appErr *errors.AppError
|
||||
require.ErrorAs(t, err, &appErr)
|
||||
assert.Equal(t, errors.ErrBadRequest, appErr.Code)
|
||||
}
|
||||
|
||||
func TestTestConnection_SQLiteAlwaysSucceeds(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
version, err := svc.TestConnection(context.Background(), types.SQLiteRetrieverEngineType, types.ConnectionConfig{})
|
||||
assert.NoError(t, err)
|
||||
assert.Empty(t, version)
|
||||
}
|
||||
|
||||
func TestTestConnection_PostgresDefaultConnection(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
version, err := svc.TestConnection(context.Background(), types.PostgresRetrieverEngineType,
|
||||
types.ConnectionConfig{UseDefaultConnection: true})
|
||||
assert.NoError(t, err)
|
||||
assert.Empty(t, version) // default connection cannot detect version without DB handle
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// validateConnectionConfig tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestValidateConnectionConfig(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
engineType types.RetrieverEngineType
|
||||
config types.ConnectionConfig
|
||||
wantError bool
|
||||
}{
|
||||
{
|
||||
name: "elasticsearch valid",
|
||||
engineType: types.ElasticsearchRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Addr: "http://es:9200"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "elasticsearch missing addr",
|
||||
engineType: types.ElasticsearchRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "postgres with default connection",
|
||||
engineType: types.PostgresRetrieverEngineType,
|
||||
config: types.ConnectionConfig{UseDefaultConnection: true},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "postgres with addr",
|
||||
engineType: types.PostgresRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Addr: "postgres://host:5432/db"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "postgres without addr or default",
|
||||
engineType: types.PostgresRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "qdrant valid",
|
||||
engineType: types.QdrantRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Host: "qdrant-host"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "qdrant missing host",
|
||||
engineType: types.QdrantRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "milvus valid",
|
||||
engineType: types.MilvusRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Addr: "milvus:19530"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "milvus missing addr",
|
||||
engineType: types.MilvusRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "weaviate valid",
|
||||
engineType: types.WeaviateRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Host: "weaviate:8080"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "weaviate missing host",
|
||||
engineType: types.WeaviateRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "sqlite always valid",
|
||||
engineType: types.SQLiteRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := validateConnectionConfig(tt.engineType, tt.config)
|
||||
if tt.wantError {
|
||||
assert.Error(t, err)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user