// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// To run these tests, set the following environment variables:
// LOGADMIN_PROJECT: Google Cloud project ID.
package cloudloggingadmin
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"os"
"regexp"
"strings"
"testing"
"time"
"cloud.google.com/go/logging"
"cloud.google.com/go/logging/logadmin"
"github.com/google/uuid"
"github.com/googleapis/genai-toolbox/internal/testutils"
"github.com/googleapis/genai-toolbox/tests"
"golang.org/x/oauth2/google"
"google.golang.org/api/option"
)
var (
LogAdminSourceType = "cloud-logging-admin"
LogAdminProject = os.Getenv("LOGADMIN_PROJECT")
)
func getLogAdminVars(t *testing.T) map[string]any {
switch "" {
case LogAdminProject:
t.Fatal("'LOGADMIN_PROJECT' not set")
}
return map[string]any{
"type": LogAdminSourceType,
"project": LogAdminProject,
}
}
// Copied over from cloud_logging_admin.go
func initLogAdminConnection(project string) (*logadmin.Client, error) {
ctx := context.Background()
cred, err := google.FindDefaultCredentials(ctx, logging.AdminScope)
if err != nil {
return nil, fmt.Errorf("failed to find default Google Cloud credentials with scope %q: %w", logging.AdminScope, err)
}
client, err := logadmin.NewClient(ctx, project, option.WithCredentials(cred))
if err != nil {
return nil, fmt.Errorf("failed to create Cloud Logging Admin client for project %q: %w", project, err)
}
return client, nil
}
// This client will be used to add logs to the project
func initLogConnection(project string) (*logging.Client, error) {
ctx := context.Background()
cred, err := google.FindDefaultCredentials(ctx, logging.WriteScope)
if err != nil {
return nil, fmt.Errorf("failed to find default Google Cloud credentials with scope %q: %w", logging.WriteScope, err)
}
client, err := logging.NewClient(ctx, project, option.WithCredentials(cred))
if err != nil {
return nil, fmt.Errorf("failed to create Cloud Logging client for project %q: %w", project, err)
}
return client, nil
}
func TestLogAdminToolEndpoints(t *testing.T) {
sourceConfig := getLogAdminVars(t)
ctx, cancel := context.WithTimeout(context.Background(), 7*time.Minute)
defer cancel()
var args []string
_, err := initLogAdminConnection(LogAdminProject)
if err != nil {
t.Fatalf("unable to connect to logs: %s", err)
}
loggingClient, err := initLogConnection(LogAdminProject)
if err != nil {
t.Fatalf("unable to connect to logging: %s", err)
}
defer loggingClient.Close()
testUUID := strings.ReplaceAll(uuid.New().String(), "-", "")
logName := fmt.Sprintf("toolbox-integration-test-%s", testUUID)
// set up test logs and wait for logs to be injested.
setupTestLogs(t, loggingClient, logName)
t.Logf("Waiting 15 seconds for log ingestion...")
time.Sleep(15 * time.Second)
// Delete test logs once test is over
defer teardownTestLogs(t, ctx, LogAdminProject, logName)
toolsFile := getCloudLoggingAdminToolsConfig(sourceConfig)
cmd, cleanup, err := tests.StartCmd(ctx, toolsFile, args...)
if err != nil {
t.Fatalf("command initialization returned an error: %s", err)
}
defer cleanup()
waitCtx, waitCancel := context.WithTimeout(ctx, 10*time.Second)
defer waitCancel()
out, err := testutils.WaitForString(waitCtx, regexp.MustCompile(`Server ready to serve`), cmd.Out)
if err != nil {
t.Logf("toolbox command logs:\n%s", out)
t.Fatalf("toolbox didn't start successfully: %s", err)
}
runListLogNamesTest(t, logName)
runAuthListLogNamesTest(t, logName)
runListResourceTypesTest(t)
runQueryLogsTest(t, logName)
runQueryLogsErrorTest(t)
}
func setupTestLogs(t *testing.T, client *logging.Client, logName string) {
logger := client.Logger(logName)
logger.Log(logging.Entry{
Payload: map[string]string{"test_id": logName, "message": "test entry 1"},
Severity: logging.Info,
Labels: map[string]string{"env": "test", "run_id": "1"},
})
logger.Log(logging.Entry{
Payload: map[string]string{"test_id": logName, "message": "test entry 2"},
Severity: logging.Warning,
})
logger.Log(logging.Entry{
Payload: map[string]string{"test_id": logName, "message": "test entry 3"},
Severity: logging.Error,
})
if err := logger.Flush(); err != nil {
t.Fatalf("failed to flush logs: %v", err)
}
}
func teardownTestLogs(t *testing.T, ctx context.Context, projectID, logName string) {
adminClient, err := logadmin.NewClient(ctx, projectID)
if err != nil {
t.Errorf("failed to create admin client for cleanup: %v", err)
return
}
defer adminClient.Close()
if err := adminClient.DeleteLog(ctx, logName); err != nil {
t.Logf("failed to delete test log %s: %v", logName, err)
}
}
func getCloudLoggingAdminToolsConfig(sourceConfig map[string]any) map[string]any {
return map[string]any{
"sources": map[string]any{
"my-logging-instance": sourceConfig,
},
"authServices": map[string]any{
"my-google-auth": map[string]any{
"type": "google",
"clientId": tests.ClientId,
},
},
"tools": map[string]any{
"list-log-names": map[string]any{
"type": "cloud-logging-admin-list-log-names",
"source": "my-logging-instance",
"description": "Lists log names in the project",
},
"list-resource-types": map[string]any{
"type": "cloud-logging-admin-list-resource-types",
"source": "my-logging-instance",
"description": "Lists monitored resource types",
},
"query-logs": map[string]any{
"type": "cloud-logging-admin-query-logs",
"source": "my-logging-instance",
"description": "Queries log entries",
},
"auth-list-log-names": map[string]any{
"type": "cloud-logging-admin-list-log-names",
"source": "my-logging-instance",
"authRequired": []string{"my-google-auth"},
"description": "Lists log names with authentication",
},
},
}
}
func runListLogNamesTest(t *testing.T, expectedLogName string) {
t.Run("list-log-names", func(t *testing.T) {
resp, respBody := tests.RunRequest(t, http.MethodPost, "http://127.0.0.1:5000/api/tool/list-log-names/invoke", bytes.NewBuffer([]byte(`{}`)), nil)
defer resp.Body.Close()
if resp.StatusCode != 200 {
t.Fatalf("expected status 200, got %d", resp.StatusCode)
}
var body map[string]interface{}
if err := json.Unmarshal(respBody, &body); err != nil {
t.Fatalf("error parsing response body")
}
result, ok := body["result"].(string)
if !ok {
t.Fatalf("expected result to be string")
}
if !strings.Contains(result, expectedLogName) {
t.Errorf("expected log name %s not found in result: %s", expectedLogName, result)
}
})
}
func runListResourceTypesTest(t *testing.T) {
t.Run("list-resource-types", func(t *testing.T) {
resp, respBody := tests.RunRequest(t, http.MethodPost, "http://127.0.0.1:5000/api/tool/list-resource-types/invoke", bytes.NewBuffer([]byte(`{}`)), nil)
if resp.StatusCode != 200 {
t.Fatalf("expected status 200, got %d", resp.StatusCode)
}
var body map[string]interface{}
if err := json.Unmarshal(respBody, &body); err != nil {
t.Fatalf("error parsing response body")
}
result, ok := body["result"].(string)
if !ok {
t.Fatalf("expected result to be string")
}
expectedTypes := []string{"global", "gce_instance", "gcs_bucket", "project"}
for _, resourceType := range expectedTypes {
if !strings.Contains(result, resourceType) {
t.Errorf("expected '%s' resource type in result, but it was missing", resourceType)
}
}
})
}
func runQueryLogsTest(t *testing.T, logName string) {
baseFilter := fmt.Sprintf(`logName="projects/%s/logs/%s"`, LogAdminProject, logName)
t.Run("query-logs-simple", func(t *testing.T) {
requestBody := fmt.Sprintf(`{"filter": %q, "limit": 10}`, baseFilter)
result := invokeQueryTool(t, requestBody)
if !strings.Contains(result, "test entry") {
t.Errorf("expected test entries in result: %s", result)
}
})
t.Run("query-logs-newest-first", func(t *testing.T) {
requestBody := fmt.Sprintf(`{"filter": %q, "limit": 10, "newestFirst": true}`, baseFilter)
result := invokeQueryTool(t, requestBody)
idx3 := strings.Index(result, "test entry 3")
idx1 := strings.Index(result, "test entry 1")
if idx3 == -1 || idx1 == -1 {
t.Fatalf("missing expected entries in result: %s", result)
}
if idx3 > idx1 {
t.Errorf("expected entry 3 to appear before entry 1 with newestFirst=true, but got: ...%s... then ...%s...", "test entry 3", "test entry 1")
}
})
t.Run("query-logs-verbose", func(t *testing.T) {
requestBody := fmt.Sprintf(`{"filter": %q, "limit": 10, "verbose": true}`, baseFilter)
result := invokeQueryTool(t, requestBody)
if !strings.Contains(result, `"labels":`) {
t.Errorf("expected 'labels' field in verbose output, got: %s", result)
}
if !strings.Contains(result, `"env":"test"`) && !strings.Contains(result, `"env": "test"`) {
t.Errorf("expected label 'env: test' in verbose output, got: %s", result)
}
})
}
func invokeQueryTool(t *testing.T, requestBody string) string {
t.Helper()
resp, respBody := tests.RunRequest(t, http.MethodPost, "http://127.0.0.1:5000/api/tool/query-logs/invoke", bytes.NewBuffer([]byte(requestBody)), nil)
defer resp.Body.Close()
if resp.StatusCode != 200 {
t.Fatalf("expected status 200, got %d", resp.StatusCode)
}
var body map[string]interface{}
if err := json.Unmarshal(respBody, &body); err != nil {
t.Fatalf("error parsing response body")
}
result, ok := body["result"].(string)
if !ok {
t.Fatalf("expected result to be string")
}
return result
}
func runAuthListLogNamesTest(t *testing.T, expectedLogName string) {
t.Run("auth-list-log-names", func(t *testing.T) {
resp, _ := tests.RunRequest(t, http.MethodPost, "http://127.0.0.1:5000/api/tool/auth-list-log-names/invoke", bytes.NewBuffer([]byte(`{}`)), nil)
if resp.StatusCode != 401 {
t.Fatalf("expected status 401 (Unauthorized), got %d", resp.StatusCode)
}
})
}
func runQueryLogsErrorTest(t *testing.T) {
t.Run("query-logs-error", func(t *testing.T) {
requestBody := `{"filter": "INVALID_FILTER_SYNTAX :::", "limit": 10}`
resp, _ := tests.RunRequest(t, http.MethodPost, "http://127.0.0.1:5000/api/tool/query-logs/invoke", bytes.NewBuffer([]byte(requestBody)), nil)
if resp.StatusCode == 200 {
t.Errorf("expected error status code, got 200 OK")
}
})
}
