metrics_visibility_test.go

package main

import (
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"testing"
	"time"

	corecommands "github.com/jfrog/jfrog-cli-core/v2/common/commands"
	coreTests "github.com/jfrog/jfrog-cli-core/v2/utils/tests"
)

type capturedRequest struct {
	Method string
	Path   string
	Body   []byte
}

type visReq struct {
	Method string
	Path   string
	Body   []byte
}

func startMockServer(t *testing.T) (*httptest.Server, chan capturedRequest) {
	t.Helper()
	ch := make(chan capturedRequest, 4)
	handler := http.NewServeMux()
	handler.HandleFunc("/artifactory/api/system/version", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(`{"version":"7.200.0"}`))
	})
	handler.HandleFunc("/artifactory/api/system/ping", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("OK"))
	})
	// Call Home stub
	handler.HandleFunc("/artifactory/api/system/usage", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("OK"))
	})
	handler.HandleFunc("/jfconnect/api/v1/backoffice/metrics/log", func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			_ = r.Body.Close()
		}()
		body, _ := io.ReadAll(r.Body)
		ch <- capturedRequest{Method: r.Method, Path: r.URL.Path, Body: body}
		w.WriteHeader(http.StatusCreated)
		_, _ = w.Write([]byte("ok"))
	})
	srv := httptest.NewServer(handler)
	return srv, ch
}

func startVisMockServer(t *testing.T) (*httptest.Server, chan visReq) {
	t.Helper()
	ch := make(chan visReq, 4)
	mux := http.NewServeMux()
	mux.HandleFunc("/artifactory/api/system/version", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(`{"version":"7.200.0"}`))
	})
	mux.HandleFunc("/artifactory/api/system/ping", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("OK"))
	})
	mux.HandleFunc("/artifactory/api/system/usage", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("OK"))
	})
	mux.HandleFunc("/jfconnect/api/v1/backoffice/metrics/log", func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			_ = r.Body.Close()
		}()
		b, _ := io.ReadAll(r.Body)
		ch <- visReq{Method: r.Method, Path: r.URL.Path, Body: b}
		w.WriteHeader(http.StatusCreated)
		_, _ = w.Write([]byte("ok"))
	})
	srv := httptest.NewServer(mux)
	return srv, ch
}

// TestVisibility_AgentContext_E2E verifies that agent execution context
// (is_agent / agent / is_interactive) flows end-to-end from env vars through
// the metrics pipeline into the visibility wire payload.
//
// ExecutionContext memoizes via sync.Once for the process lifetime, and other
// tests in this binary trigger the metrics path first under `go test`, so we
// must reset the cache before re-evaluating env vars and reset again on
// cleanup so this test cannot leak agent state into anything that follows.
func TestVisibility_AgentContext_E2E(t *testing.T) {
	corecommands.ResetExecutionContextForTest()
	t.Cleanup(corecommands.ResetExecutionContextForTest)
	t.Setenv("CURSOR_AGENT", "1")

	srv, ch := startMockServer(t)
	defer srv.Close()

	home := t.TempDir()
	t.Setenv("JFROG_CLI_HOME_DIR", home)
	t.Setenv("JFROG_CLI_REPORT_USAGE", "true")

	jf := coreTests.NewJfrogCli(execMain, "jf", "").WithoutCredentials()
	platformURL := srv.URL + "/"
	artURL := srv.URL + "/artifactory/"
	if err := jf.Exec("c", "add", "agent-mock",
		"--url", platformURL,
		"--artifactory-url", artURL,
		"--access-token", "dummy",
		"--interactive=false",
		"--enc-password=false",
	); err != nil {
		t.Fatalf("config add failed: %v", err)
	}
	if err := jf.Exec("c", "use", "agent-mock"); err != nil {
		t.Fatalf("config use failed: %v", err)
	}

	if err := jf.Exec("rt", "ping", "--server-id", "agent-mock"); err != nil {
		t.Fatalf("jf exec failed: %v", err)
	}

	select {
	case req := <-ch:
		if req.Path != "/jfconnect/api/v1/backoffice/metrics/log" {
			t.Fatalf("unexpected path: %s", req.Path)
		}
		var payload struct {
			Labels struct {
				IsAgent       string `json:"is_agent"`
				Agent         string `json:"agent"`
				IsInteractive string `json:"is_interactive"`
			} `json:"labels"`
		}
		if err := json.Unmarshal(req.Body, &payload); err != nil {
			t.Fatalf("bad JSON: %v\nbody: %s", err, string(req.Body))
		}
		if payload.Labels.IsAgent != "true" {
			t.Errorf("is_agent: got %q want %q (body: %s)", payload.Labels.IsAgent, "true", string(req.Body))
		}
		if payload.Labels.Agent != "cursor" {
			t.Errorf("agent: got %q want %q (body: %s)", payload.Labels.Agent, "cursor", string(req.Body))
		}
		// Stdout is not a TTY under `go test`, so is_interactive should be "false".
		if payload.Labels.IsInteractive != "false" {
			t.Errorf("is_interactive: got %q want %q (body: %s)", payload.Labels.IsInteractive, "false", string(req.Body))
		}
	case <-time.After(5 * time.Second):
		t.Fatalf("timeout waiting for metrics POST")
	}
}

// TestVisibility_NoAgent_E2E is the negative counterpart to
// TestVisibility_AgentContext_E2E: with no agent env var set, the wire payload
// must carry is_agent="false" and an empty agent name. ExecutionContext is
// reset because the positive test above memoizes IsAgent=true earlier in this
// binary.
func TestVisibility_NoAgent_E2E(t *testing.T) {
	corecommands.ResetExecutionContextForTest()
	t.Cleanup(corecommands.ResetExecutionContextForTest)
	t.Setenv("CURSOR_AGENT", "")
	t.Setenv("CLAUDECODE", "")
	t.Setenv("AGENT", "")

	srv, ch := startMockServer(t)
	defer srv.Close()

	home := t.TempDir()
	t.Setenv("JFROG_CLI_HOME_DIR", home)
	t.Setenv("JFROG_CLI_REPORT_USAGE", "true")

	jf := coreTests.NewJfrogCli(execMain, "jf", "").WithoutCredentials()
	platformURL := srv.URL + "/"
	artURL := srv.URL + "/artifactory/"
	if err := jf.Exec("c", "add", "noagent-mock",
		"--url", platformURL,
		"--artifactory-url", artURL,
		"--access-token", "dummy",
		"--interactive=false",
		"--enc-password=false",
	); err != nil {
		t.Fatalf("config add failed: %v", err)
	}
	if err := jf.Exec("c", "use", "noagent-mock"); err != nil {
		t.Fatalf("config use failed: %v", err)
	}
	if err := jf.Exec("rt", "ping", "--server-id", "noagent-mock"); err != nil {
		t.Fatalf("jf exec failed: %v", err)
	}

	select {
	case req := <-ch:
		if req.Path != "/jfconnect/api/v1/backoffice/metrics/log" {
			t.Fatalf("unexpected path: %s", req.Path)
		}
		var payload struct {
			Labels struct {
				IsAgent string `json:"is_agent"`
				Agent   string `json:"agent"`
			} `json:"labels"`
		}
		if err := json.Unmarshal(req.Body, &payload); err != nil {
			t.Fatalf("bad JSON: %v\nbody: %s", err, string(req.Body))
		}
		if payload.Labels.IsAgent != "false" {
			t.Errorf("is_agent: got %q want %q (body: %s)", payload.Labels.IsAgent, "false", string(req.Body))
		}
		if payload.Labels.Agent != "" {
			t.Errorf("agent: got %q want %q (body: %s)", payload.Labels.Agent, "", string(req.Body))
		}
	case <-time.After(5 * time.Second):
		t.Fatalf("timeout waiting for metrics POST")
	}
}

func TestVisibilitySendUsage_RtCurl_E2E(t *testing.T) {
	srv, ch := startMockServer(t)
	defer srv.Close()

	// Isolate CLI home and enable usage reporting
	home := t.TempDir()
	_ = os.Setenv("JFROG_CLI_HOME_DIR", home)
	_ = os.Setenv("JFROG_CLI_REPORT_USAGE", "true")

	jf := coreTests.NewJfrogCli(execMain, "jf", "").WithoutCredentials()

	// Create mock server config pointing to the httptest server
	platformURL := srv.URL + "/"
	artURL := srv.URL + "/artifactory/"
	if err := jf.Exec(
		"c", "add", "mock",
		"--url", platformURL,
		"--artifactory-url", artURL,
		"--access-token", "dummy",
		"--interactive=false",
		"--enc-password=false",
	); err != nil {
		t.Fatalf("config add failed: %v", err)
	}
	if err := jf.Exec("c", "use", "mock"); err != nil {
		t.Fatalf("config use failed: %v", err)
	}

	// Run real CLI command pointing to mock Artifactory via server-id
	if err := jf.Exec("rt", "curl", "-X", "POST", "/api/system/ping", "--server-id", "mock"); err != nil {
		t.Fatalf("jf exec failed: %v", err)
	}

	// Assert metric was posted
	select {
	case req := <-ch:
		if req.Method != http.MethodPost {
			t.Fatalf("expected POST, got %s", req.Method)
		}
		if req.Path != "/jfconnect/api/v1/backoffice/metrics/log" {
			t.Fatalf("unexpected path: %s", req.Path)
		}
		var payload struct {
			Name   string `json:"metrics_name"`
			Labels struct {
				Flags     string `json:"flags"`
				FeatureID string `json:"feature_id"`
			} `json:"labels"`
		}
		if err := json.Unmarshal(req.Body, &payload); err != nil {
			t.Fatalf("bad JSON: %v", err)
		}
		if payload.Name != "jfcli_commands_count" {
			t.Fatalf("unexpected metric name: %s", payload.Name)
		}
		if payload.Labels.FeatureID != "rt_curl" {
			t.Fatalf("unexpected feature_id: %s", payload.Labels.FeatureID)
		}
		// rt curl removes flags internally; expect empty
		if payload.Labels.Flags != "" {
			t.Fatalf("expected empty flags string, got %q", payload.Labels.Flags)
		}
	case <-time.After(5 * time.Second):
		t.Fatalf("timeout waiting for metrics POST")
	}
}

func TestVisibilitySendUsage_RtPing_Flags(t *testing.T) {
	srv, ch := startMockServer(t)
	defer srv.Close()

	// Isolate CLI home and enable usage reporting
	home := t.TempDir()
	_ = os.Setenv("JFROG_CLI_HOME_DIR", home)
	_ = os.Setenv("JFROG_CLI_REPORT_USAGE", "true")

	jf := coreTests.NewJfrogCli(execMain, "jf", "").WithoutCredentials()

	// Create mock server config pointing to the httptest server
	platformURL := srv.URL + "/"
	artURL := srv.URL + "/artifactory/"
	if err := jf.Exec(
		"c", "add", "mock",
		"--url", platformURL,
		"--artifactory-url", artURL,
		"--access-token", "dummy",
		"--interactive=false",
		"--enc-password=false",
	); err != nil {
		t.Fatalf("config add failed: %v", err)
	}
	if err := jf.Exec("c", "use", "mock"); err != nil {
		t.Fatalf("config use failed: %v", err)
	}

	// Run ping with a flag to assert capture
	err := jf.Exec("rt", "ping", "--server-id", "mock")
	if err != nil {
		t.Logf("jf exec failed: %v", err)
	}

	// Assert metric was posted with expected flags
	select {
	case req := <-ch:
		if req.Path != "/jfconnect/api/v1/backoffice/metrics/log" {
			t.Fatalf("unexpected path: %s", req.Path)
		}
		var payload struct {
			Labels struct {
				Flags string `json:"flags"`
			} `json:"labels"`
		}
		if err := json.Unmarshal(req.Body, &payload); err != nil {
			t.Fatalf("bad JSON: %v", err)
		}
		if payload.Labels.Flags != "server-id" {
			t.Fatalf("flags mismatch: got %q want %q", payload.Labels.Flags, "server-id")
		}
	case <-time.After(5 * time.Second):
		t.Fatalf("timeout waiting for metrics POST")
	}
}

func TestVisibility_GoBuild_Flags(t *testing.T) {
	srv, ch := startVisMockServer(t)
	defer srv.Close()

	// Isolated home and enable usage
	home := t.TempDir()
	_ = os.Setenv("JFROG_CLI_HOME_DIR", home)
	_ = os.Setenv("JFROG_CLI_REPORT_USAGE", "true")

	jf := coreTests.NewJfrogCli(execMain, "jf", "").WithoutCredentials()

	// Configure mock platform
	platformURL := srv.URL + "/"
	artURL := srv.URL + "/artifactory/"
	if err := jf.Exec("c", "add", "mock", "--url", platformURL, "--artifactory-url", artURL, "--access-token", "dummy", "--interactive=false", "--enc-password=false"); err != nil {
		t.Fatalf("config add failed: %v", err)
	}
	if err := jf.Exec("c", "use", "mock"); err != nil {
		t.Fatalf("config use failed: %v", err)
	}

	// Create a minimal Go project
	projDir := t.TempDir()
	goMod := []byte("module example.com/jfvis\n\ngo 1.21\n")
	mainGo := []byte("package main\nfunc main(){}\n")
	if err := os.WriteFile(projDir+"/go.mod", goMod, 0o644); err != nil {
		t.Fatalf("write go.mod: %v", err)
	}
	if err := os.WriteFile(projDir+"/main.go", mainGo, 0o644); err != nil {
		t.Fatalf("write main.go: %v", err)
	}
	// Provide a minimal buildtools config so GoCmd passes verification
	if err := os.MkdirAll(projDir+"/.jfrog/projects", 0o755); err != nil {
		t.Fatalf("mkdir .jfrog/projects: %v", err)
	}
	goYaml := []byte("version: 1\n" +
		"type: go\n" +
		"resolver:\n" +
		"    repo: go-virtual\n" +
		"    serverId: mock\n" +
		"deployer:\n" +
		"    repo: go-virtual\n" +
		"    serverId: mock\n")
	if err := os.WriteFile(projDir+"/.jfrog/projects/go.yaml", goYaml, 0o644); err != nil {
		t.Fatalf("write go.yaml: %v", err)
	}
	cwd, _ := os.Getwd()
	defer func(dir string) {
		err := os.Chdir(dir)
		if err != nil {
			t.Fatalf("Failed to restore working directory: %v", err)
		}
	}(cwd)
	_ = os.Chdir(projDir)

	// Run a buildtools command (go build) with flags; ignore execution error
	_ = jf.Exec("go", "build", "--build-name", "test", "--build-number", "1", "--server-id", "mock")

	select {
	case req := <-ch:
		if req.Path != "/jfconnect/api/v1/backoffice/metrics/log" {
			t.Fatalf("unexpected path: %s", req.Path)
		}
		var p struct {
			Labels struct {
				Flags string `json:"flags"`
			} `json:"labels"`
		}
		if err := json.Unmarshal(req.Body, &p); err != nil {
			t.Fatalf("bad JSON: %v", err)
		}
		if p.Labels.Flags != "build-name,build-number,server-id" {
			t.Fatalf("flags mismatch: got %q want %q", p.Labels.Flags, "build-name,build-number,server-id")
		}
	case <-time.After(15 * time.Second):
		t.Fatal("timeout waiting for metric")
	}
}

func TestVisibility_PackageAlias_Metrics(t *testing.T) {
	// This test requires the ghost frog binary and alias setup.
	homeDir := initGhostFrogTest(t)

	srv, ch := startVisMockServer(t)
	defer srv.Close()

	// Install npm alias (creates symlink npm -> jf in alias bin dir)
	installAliases(t, "npm")

	// Configure the CLI to point at the mock server
	platformURL := srv.URL + "/"
	artURL := srv.URL + "/artifactory/"
	out, err := runJfCommand(t, "c", "add", "mock", "--url", platformURL, "--artifactory-url", artURL,
		"--access-token", "dummy", "--interactive=false", "--enc-password=false")
	if err != nil {
		t.Fatalf("config add failed: %s %v", out, err)
	}
	out, err = runJfCommand(t, "c", "use", "mock")
	if err != nil {
		t.Fatalf("config use failed: %s %v", out, err)
	}

	// Create a minimal npm project with JFrog config so "jf npm install" passes validation.
	projDir := t.TempDir()
	if err := os.WriteFile(projDir+"/package.json", []byte(`{"name":"test","version":"1.0.0"}`), 0o644); err != nil {
		t.Fatalf("write package.json: %v", err)
	}
	if err := os.MkdirAll(projDir+"/.jfrog/projects", 0o755); err != nil {
		t.Fatalf("mkdir .jfrog/projects: %v", err)
	}
	npmYaml := []byte("version: 1\ntype: npm\nresolver:\n    repo: npm-virtual\n    serverId: mock\ndeployer:\n    repo: npm-virtual\n    serverId: mock\n")
	if err := os.WriteFile(projDir+"/.jfrog/projects/npm.yaml", npmYaml, 0o644); err != nil {
		t.Fatalf("write npm.yaml: %v", err)
	}

	// Run the npm alias which triggers DispatchIfAlias -> runJFMode -> SetPackageAliasContext("npm")
	// Then falls through to "jf npm install" which triggers metrics reporting.
	npmPath := aliasToolPath(homeDir, "npm")
	binDir := aliasBinDir(homeDir)
	cmd := exec.Command(npmPath, "install")
	cmd.Dir = projDir
	cmd.Env = append(os.Environ(),
		"JFROG_CLI_HOME_DIR="+homeDir,
		"JFROG_CLI_REPORT_USAGE=true",
		"JFROG_CLI_LOG_LEVEL=DEBUG",
		"PATH="+binDir+string(os.PathListSeparator)+os.Getenv("PATH"),
	)
	cmdOut, _ := cmd.CombinedOutput()
	t.Logf("npm alias output: %s", string(cmdOut))

	select {
	case req := <-ch:
		if req.Path != "/jfconnect/api/v1/backoffice/metrics/log" {
			t.Fatalf("unexpected path: %s", req.Path)
		}
		var payload struct {
			Labels struct {
				PackageAlias   string `json:"package_alias"`
				PackageManager string `json:"package_manager"`
			} `json:"labels"`
		}
		t.Logf("RAW PAYLOAD: %s", string(req.Body))
		if err := json.Unmarshal(req.Body, &payload); err != nil {
			t.Fatalf("bad JSON: %v", err)
		}
		if payload.Labels.PackageAlias != "true" {
			t.Errorf("expected package_alias=true, got %q", payload.Labels.PackageAlias)
		}
		if payload.Labels.PackageManager != "npm" {
			t.Errorf("expected package_manager=npm, got %q", payload.Labels.PackageManager)
		}
	case <-time.After(15 * time.Second):
		t.Fatal("timeout waiting for metrics POST")
	}
}