feat: add GET endpoint by primitive kind

Author: Yuan325

internal/server/admin.go

@@ -37,7 +37,10 @@ func adminRouter(s *Server) (chi.Router, error) {
 
 	r.Put("/{kind}/{name}", func(w http.ResponseWriter, r *http.Request) { createOrUpdatePrimitives(s, w, r) })
 	r.Delete("/{kind}/{name}", func(w http.ResponseWriter, r *http.Request) { deletePrimitives(s, w, r) })
-	r.Get("/{kind}/{name}", func(w http.ResponseWriter, r *http.Request) { getPrimitiveByName(s, w, r) })
+	r.Route("/{kind}", func(r chi.Router) {
+		r.Get("/", func(w http.ResponseWriter, r *http.Request) { getPrimitive(s, w, r) })
+		r.Get("/{name}", func(w http.ResponseWriter, r *http.Request) { getPrimitiveByName(s, w, r) })
+	})
 
 	return r, nil
 }
@@ -167,6 +170,33 @@ func createOrUpdatePrimitives(s *Server, w http.ResponseWriter, r *http.Request)
 	}
 }
 
+func getPrimitive(s *Server, w http.ResponseWriter, r *http.Request) {
+	kind := chi.URLParam(r, "kind")
+	ctx := r.Context()
+
+	var primitive []string
+	switch strings.ToLower(kind) {
+	case "source":
+		primitive = s.ResourceMgr.GetSources()
+	case "authservice":
+		primitive = s.ResourceMgr.GetAuthServices()
+	case "embeddingmodel":
+		primitive = s.ResourceMgr.GetEmbeddingModels()
+	case "tool":
+		primitive = s.ResourceMgr.GetTools()
+	case "toolset":
+		primitive = s.ResourceMgr.GetToolsets()
+	case "prompt":
+		primitive = s.ResourceMgr.GetPrompts()
+	default:
+		err := fmt.Errorf("invalid primitive kind provided")
+		s.logger.DebugContext(ctx, err.Error())
+		_ = render.Render(w, r, newErrResponse(err, http.StatusBadRequest))
+		return
+	}
+	render.JSON(w, r, primitive)
+}
+
 func getPrimitiveByName(s *Server, w http.ResponseWriter, r *http.Request) {
 	kind := chi.URLParam(r, "kind")
 	name := chi.URLParam(r, "name")

internal/server/admin_test.go

@@ -229,6 +229,97 @@ func TestAdminDeleteEndpoint(t *testing.T) {
 }
 
 func TestAdminGetEndpoint(t *testing.T) {
+	mockSource := testutils.MockSource{MockSourceConfig: testutils.MockSourceConfig{Foo: "foo", Password: "password"}}
+	mockAuthService := testutils.MockAuthService{MockAuthServiceConfig: testutils.MockAuthServiceConfig{Foo: "foo"}}
+	mockEmbeddingModel := testutils.MockEmbeddingModel{MockEmbeddingModelConfig: testutils.MockEmbeddingModelConfig{Foo: "foo"}}
+	mockTool := testutils.MockTool{MockToolConfig: testutils.MockToolConfig{Foo: "foo"}}
+	mockToolset := tools.Toolset{ToolsetConfig: tools.ToolsetConfig{ToolNames: []string{"test-tool"}}}
+	mockPrompt := testutils.MockPrompt{MockPromptConfig: testutils.MockPromptConfig{Foo: "foo"}}
+
+	mockSources := map[string]sources.Source{"test-source": mockSource}
+	mockAuthServices := map[string]auth.AuthService{"test-auth-service": mockAuthService}
+	mockEmbeddingModels := map[string]embeddingmodels.EmbeddingModel{"test-embedding-model": mockEmbeddingModel}
+	mockTools := map[string]tools.Tool{"test-tool": mockTool}
+	mockToolsets := map[string]tools.Toolset{"test-toolset": mockToolset}
+	mockPrompts := map[string]prompts.Prompt{"test-prompt": mockPrompt}
+
+	r, shutdown := setUpServer(t, "admin", mockSources, mockAuthServices, mockEmbeddingModels, mockTools, mockToolsets, mockPrompts, map[string]prompts.Promptset{})
+	defer shutdown()
+	ts := runServer(r, false)
+	defer ts.Close()
+
+	tests := []struct {
+		name               string
+		kind               string
+		want               []string
+		expectedStatusCode int
+	}{
+		{
+			name:               "Get Source - Success",
+			kind:               "source",
+			want:               []string{"test-source"},
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Get Auth Service - Success",
+			kind:               "authService",
+			want:               []string{"test-auth-service"},
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Get Embedding Model - Success",
+			kind:               "embeddingModel",
+			want:               []string{"test-embedding-model"},
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Get Tool - Success",
+			kind:               "tool",
+			want:               []string{"test-tool"},
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Get Toolset - Success",
+			kind:               "toolset",
+			want:               []string{"test-toolset"},
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Get Prompt - Success",
+			kind:               "prompt",
+			want:               []string{"test-prompt"},
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Get with Invalid Kind - Bad Request",
+			kind:               "invalidKind",
+			expectedStatusCode: http.StatusBadRequest,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			resp, body, err := runRequest(ts, http.MethodGet, fmt.Sprintf("/%s", tt.kind), nil, nil)
+			if err != nil {
+				t.Fatalf("unexpected error during request: %s", err)
+			}
+			if resp.StatusCode != tt.expectedStatusCode {
+				t.Fatalf("response status code is not %d, got %d, %s", tt.expectedStatusCode, resp.StatusCode, string(body))
+			}
+			if tt.expectedStatusCode == http.StatusOK {
+				var got []string
+				if err := json.Unmarshal(body, &got); err != nil {
+					t.Fatalf("error unmarshaling response body")
+				}
+				if !reflect.DeepEqual(got, tt.want) {
+					t.Fatalf("unexpected output: got %+v, want %+v", got, tt.want)
+				}
+			}
+		})
+	}
+}
+
+func TestAdminGetByNameEndpoint(t *testing.T) {
 	mockSource := testutils.MockSource{MockSourceConfig: testutils.MockSourceConfig{Foo: "foo", Password: "password"}}
 	mockSourceConfigMasked := testutils.MockSourceConfig{Foo: "foo", Password: "***"}
 	mockAuthService := testutils.MockAuthService{MockAuthServiceConfig: testutils.MockAuthServiceConfig{Foo: "foo"}}

internal/server/resources/resources.go

@@ -17,7 +17,9 @@ package resources
 import (
 	"context"
 	"fmt"
+	"maps"
 	"reflect"
+	"slices"
 	"sync"
 
 	"github.com/googleapis/genai-toolbox/internal/auth"
@@ -76,6 +78,42 @@ func (r *ResourceManager) SetResources(sourcesMap map[string]sources.Source, aut
 	r.promptsets = promptsetsMap
 }
 
+func (r *ResourceManager) GetSources() []string {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return slices.Collect(maps.Keys(r.sources))
+}
+
+func (r *ResourceManager) GetAuthServices() []string {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return slices.Collect(maps.Keys(r.authServices))
+}
+
+func (r *ResourceManager) GetEmbeddingModels() []string {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return slices.Collect(maps.Keys(r.embeddingModels))
+}
+
+func (r *ResourceManager) GetTools() []string {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return slices.Collect(maps.Keys(r.tools))
+}
+
+func (r *ResourceManager) GetToolsets() []string {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return slices.Collect(maps.Keys(r.toolsets))
+}
+
+func (r *ResourceManager) GetPrompts() []string {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return slices.Collect(maps.Keys(r.prompts))
+}
+
 func (r *ResourceManager) GetSource(sourceName string) (sources.Source, bool) {
 	r.mu.RLock()
 	defer r.mu.RUnlock()

internal/server/resources/resources_test.go

@@ -346,3 +346,46 @@ func TestDeletePrimitives(t *testing.T) {
 		t.Fatalf("expected delete to be successful")
 	}
 }
+
+func TestGetPrimitives(t *testing.T) {
+	resMgr := resources.NewResourceManager(
+		map[string]sources.Source{"foo": testutils.MockSource{}},
+		map[string]auth.AuthService{"foo": testutils.MockAuthService{}},
+		map[string]embeddingmodels.EmbeddingModel{"foo": testutils.MockEmbeddingModel{}},
+		map[string]tools.Tool{"foo": testutils.MockTool{}},
+		map[string]tools.Toolset{"foo": tools.Toolset{}},
+		map[string]prompts.Prompt{"foo": testutils.MockPrompt{}},
+		map[string]prompts.Promptset{},
+	)
+	want := []string{"foo"}
+
+	got := resMgr.GetSources()
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected sources list: got %v, want %v", got, want)
+	}
+
+	got = resMgr.GetAuthServices()
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected auth services list: got %v, want %v", got, want)
+	}
+
+	got = resMgr.GetEmbeddingModels()
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected embedding models list: got %v, want %v", got, want)
+	}
+
+	got = resMgr.GetTools()
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected tools list: got %v, want %v", got, want)
+	}
+
+	got = resMgr.GetToolsets()
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected toolsets list: got %v, want %v", got, want)
+	}
+
+	got = resMgr.GetPrompts()
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected prompts list: got %v, want %v", got, want)
+	}
+}