feat: support filter stores by kinds

console/atest-ui/src/components/TestSuiteCreationDialog.vue

@@ -25,7 +25,7 @@ function loadStores() {
             'X-Auth': API.getToken()
         }
     }
-    fetch('/api/v1/stores', requestOptions)
+    fetch('/api/v1/stores?kind=store', requestOptions)
         .then(API.DefaultResponseProcess)
         .then(async (d) => {
             stores.value = d.data

console/atest-ui/src/components/TestSuiteImportDialog.vue

@@ -53,7 +53,7 @@ function loadStores() {
             'X-Auth': API.getToken()
         }
     }
-    fetch('/api/v1/stores', requestOptions)
+    fetch('/api/v1/stores?kind=store', requestOptions)
         .then(API.DefaultResponseProcess)
         .then(async (d) => {
             stores.value = d.data

console/atest-ui/src/views/TestingPanel.vue

@@ -166,7 +166,7 @@ function loadStores(lastSuitName?: string, lastCaseName?: string) {
       'X-Auth': API.getToken()
     }
   }
-  fetch('/api/v1/stores', requestOptions)
+  fetch('/api/v1/stores?kind=store', requestOptions)
     .then(API.DefaultResponseProcess)
     .then(async (d) => {
       stores.value = d.data

pkg/server/convert.go

@@ -29,9 +29,11 @@ func ToGRPCStore(store testing.Store) (result *Store) {
 		Name:  store.Name,
 		Owner: store.Owner,
 		Kind: &StoreKind{
-			Name:    store.Kind.Name,
-			Url:     store.Kind.URL,
-			Enabled: store.Kind.Enabled,
+			Name:       store.Kind.Name,
+			Url:        store.Kind.URL,
+			Enabled:    store.Kind.Enabled,
+			Categories: store.Kind.Categories,
+			Link:       store.Kind.Link,
 		},
 		Description: store.Description,
 		Url:         store.URL,
@@ -57,8 +59,10 @@ func ToNormalStore(store *Store) (result testing.Store) {
 	}
 	if store.Kind != nil {
 		result.Kind = testing.StoreKind{
-			Name: store.Kind.Name,
-			URL:  store.Kind.Url,
+			Name:       store.Kind.Name,
+			URL:        store.Kind.Url,
+			Link:       store.Kind.Link,
+			Categories: store.Kind.Categories,
 		}
 	}
 	return

pkg/server/remote_server.go

@@ -122,6 +122,7 @@ func NewRemoteServer(loader testing.Writer, storeWriterFactory testing.StoreWrit
 	if secretServer == nil {
 		secretServer = &fakeSecretServer{}
 	}
+	loader.WithUserConfigDir(configDir)
 	GrpcMaxRecvMsgSize = grpcMaxRecvMsgSize
 	return &server{
 		loader:             loader,
@@ -193,7 +194,7 @@ func resetEnv(oldEnv map[string]string) {
 	}
 }
 
-func (s *server) getLoaders(ctx context.Context) (loader []testing.Writer, err error) {
+func (s *server) getLoaders() (loader []testing.Writer, err error) {
 	var stores []testing.Store
 	if stores, err = testing.NewStoreFactory(s.configDir).GetStores(); err != nil {
 		return
@@ -1169,17 +1170,28 @@ func (s *server) GetStoreKinds(context.Context, *Empty) (kinds *StoreKinds, err
 		kinds = &StoreKinds{}
 		for _, store := range stores {
 			kinds.Data = append(kinds.Data, &StoreKind{
-				Name:    store.Name,
-				Enabled: true,
-				Url:     store.URL,
-				Link:    store.Link,
-				Params:  convertStoreKindParams(store.Params),
+				Name:         store.Name,
+				Enabled:      true,
+				Url:          store.URL,
+				Link:         store.Link,
+				Params:       convertStoreKindParams(store.Params),
+				Categories:   store.Categories,
+				Dependencies: convertStoreKindDependencies(store.Dependencies),
 			})
 		}
 	}
 	return
 }
 
+func convertStoreKindDependencies(dependencies []testing.StoreKindDependency) (result []*StoreKindDependency) {
+	for _, dependency := range dependencies {
+		result = append(result, &StoreKindDependency{
+			Name: dependency.Name,
+		})
+	}
+	return
+}
+
 func convertStoreKindParams(params []testing.StoreKindParam) (result []*StoreKindParam) {
 	for _, param := range params {
 		result = append(result, &StoreKindParam{
@@ -1192,21 +1204,44 @@ func convertStoreKindParams(params []testing.StoreKindParam) (result []*StoreKin
 	return
 }
 
-func (s *server) GetStores(ctx context.Context, in *Empty) (reply *Stores, err error) {
+func (s *server) GetStores(ctx context.Context, in *SimpleQuery) (reply *Stores, err error) {
 	user := oauth.GetUserFromContext(ctx)
 	storeFactory := testing.NewStoreFactory(s.configDir)
 	var stores []testing.Store
 	var owner string
 	if user != nil {
 		owner = user.Name
 	}
+
+	var kinds *StoreKinds
+	if kinds, err = s.GetStoreKinds(ctx, &Empty{}); err != nil {
+		return
+	}
+
 	if stores, err = storeFactory.GetStoresByOwner(owner); err == nil {
 		reply = &Stores{
 			Data: make([]*Store, 0),
 		}
 		wg := sync.WaitGroup{}
 		mu := sync.Mutex{}
 		for _, item := range stores {
+			skip := false
+			for _, kind := range kinds.Data {
+				if in != nil && in.Kind != "" && !slices.Contains(kind.Categories, in.Kind) {
+					skip = true
+					break
+				}
+
+				if item.Kind.Name == kind.Name {
+					item.Kind.Categories = kind.Categories
+					item.Kind.Link = kind.Link
+					break
+				}
+			}
+			if skip {
+				continue
+			}
+
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
@@ -1231,8 +1266,10 @@ func (s *server) GetStores(ctx context.Context, in *Empty) (reply *Stores, err e
 			return strings.Compare(a.Name, b.Name)
 		})
 		reply.Data = append(reply.Data, &Store{
-			Name:  "local",
-			Kind:  &StoreKind{},
+			Name: "local",
+			Kind: &StoreKind{
+				Categories: []string{"store"},
+			},
 			Ready: true,
 		})
 	}
@@ -1413,7 +1450,7 @@ func (s *server) GetMenus(ctx context.Context, _ *Empty) (result *MenuList, err
 
 	result = &MenuList{}
 	var loaders []testing.Writer
-	if loaders, err = s.getLoaders(ctx); err != nil {
+	if loaders, err = s.getLoaders(); err != nil {
 		return
 	}
 

pkg/server/remote_server_test.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2024 API Testing Authors.
+Copyright 2024-2025 API Testing Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"path/filepath"
 	"reflect"
 	"sync"
 	"sync/atomic"
@@ -871,7 +872,7 @@ func TestStoreManager(t *testing.T) {
 		server, clean := getRemoteServerInTempDir()
 		defer clean()
 
-		reply, err := server.GetStores(ctx, &Empty{})
+		reply, err := server.GetStores(ctx, &SimpleQuery{})
 		assert.NoError(t, err)
 		if assert.Equal(t, 1, len(reply.Data)) {
 			assert.Equal(t, "local", reply.Data[0].Name)
@@ -888,7 +889,7 @@ func TestStoreManager(t *testing.T) {
 		assert.NotNil(t, reply)
 
 		var stores *Stores
-		stores, err = server.GetStores(ctx, &Empty{})
+		stores, err = server.GetStores(ctx, &SimpleQuery{})
 		assert.NoError(t, err)
 		assert.Equal(t, 2, len(stores.Data))
 	})
@@ -950,10 +951,21 @@ func TestRemoteRunnerAdapter(t *testing.T) {
 	assert.Error(t, err)
 }
 
+//go:embed testdata/extension.yaml
+var extensionConfig []byte
+
 func getRemoteServerInTempDir() (server RunnerServer, call func()) {
 	dir, _ := os.MkdirTemp(os.TempDir(), "remote-server-test")
 	call = func() { os.RemoveAll(dir) }
 
+	corePath := filepath.Join(dir, "data", "core")
+	os.MkdirAll(corePath, 0755)
+	os.WriteFile(filepath.Join(corePath, "extension.yaml"), extensionConfig, 0755)
+
+	themePath := filepath.Join(dir, "data", "theme")
+	os.MkdirAll(themePath, 0755)
+	os.WriteFile(filepath.Join(themePath, "simple.json"), []byte(simplePostman), 0755)
+
 	writer := atest.NewFileWriter(dir)
 	server = NewRemoteServer(writer, newLocalloaderFromStore(), nil, nil, dir, 1024*1024*4)
 	return
@@ -1039,3 +1051,32 @@ func (s *fakeServerStream) RecvMsg(m interface{}) error {
 
 	return nil
 }
+
+func TestGetStoreKinds(t *testing.T) {
+	server, clean := getRemoteServerInTempDir()
+	defer clean()
+
+	reply, err := server.GetStoreKinds(context.Background(), &Empty{})
+	assert.NoError(t, err)
+
+	assert.Equal(t, 1, len(reply.Data))
+}
+
+func TestGetThemes(t *testing.T) {
+	server, clean := getRemoteServerInTempDir()
+	defer clean()
+
+	themeServer, ok := server.(ThemeExtensionServer)
+	assert.True(t, ok)
+
+	reply, err := themeServer.GetThemes(context.Background(), &Empty{})
+	assert.NoError(t, err)
+	assert.Equal(t, 1, len(reply.Data))
+
+	var theme *CommonResult
+	theme, err = themeServer.GetTheme(context.Background(), &SimpleName{
+		Name: "simple",
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, theme)
+}