rvbox/cmd/rvbox/main_test.go

package main

import (
	"bytes"
	"context"
	"errors"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"github.com/rvbox/rvbox/internal/client/spool"
	"github.com/rvbox/rvbox/internal/config"
	"github.com/rvbox/rvbox/internal/observability"
)

func TestClientModeSelectionRequiresExactlyOneMode_HP_WINCLI_01(t *testing.T) {
	t.Parallel()
	var output, diagnostics bytes.Buffer
	if err := run([]string{"--help"}, &output, &diagnostics); err != nil || !bytes.Contains(output.Bytes(), []byte("--service")) {
		t.Fatalf("help = %q, %v", output.String(), err)
	}
	if err := run(nil, &output, &diagnostics); err == nil {
		t.Fatal("empty client invocation accepted")
	}
	if err := run([]string{"--service", "--check-config"}, &output, &diagnostics); err == nil {
		t.Fatal("multiple client modes accepted")
	}
}

func TestClientVersionDoesNotRequireConfiguration_HP_WINCLI_03(t *testing.T) {
	t.Parallel()
	var output, diagnostics bytes.Buffer
	if err := run([]string{"--version"}, &output, &diagnostics); err != nil || output.String() != "dev\n" {
		t.Fatalf("version = %q, %v", output.String(), err)
	}
}

func TestClientHTTPClientAcceptsMatchingSelfSignedLeaf(t *testing.T) {
	t.Parallel()
	server := httptest.NewTLSServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		writer.WriteHeader(http.StatusNoContent)
	}))
	defer server.Close()

	client, err := clientHTTPClient(config.TLS{ServerName: "example.com"})
	if err != nil {
		t.Fatalf("clientHTTPClient: %v", err)
	}
	response, err := client.Get(server.URL)
	if err != nil {
		t.Fatalf("self-signed request: %v", err)
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusNoContent {
		t.Fatalf("status = %d, want %d", response.StatusCode, http.StatusNoContent)
	}
}

func TestClientHTTPClientRejectsWrongNameSelfSignedLeaf(t *testing.T) {
	t.Parallel()
	server := httptest.NewTLSServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		writer.WriteHeader(http.StatusNoContent)
	}))
	defer server.Close()

	client, err := clientHTTPClient(config.TLS{ServerName: "wrong-name.invalid"})
	if err != nil {
		t.Fatalf("clientHTTPClient: %v", err)
	}
	if _, err := client.Get(server.URL); err == nil {
		t.Fatal("self-signed request with wrong name unexpectedly succeeded")
	}
}

func TestNonWindowsServiceModesRemainExplicitlyUnsupported_BH_WINCLI_01(t *testing.T) {
	t.Parallel()
	if err := runService("", nil); err == nil {
		t.Fatal("non-Windows service mode unexpectedly available")
	}
	if err := runTray("", nil); err == nil {
		t.Fatal("non-Windows tray mode unexpectedly available")
	}
}

func TestPackagedClientConfigUsesMinimalSafeDefaults_HP_WINCLI_04(t *testing.T) {
	t.Parallel()
	content, err := packagedClientConfig("wss://controller.example.test/v1/agent", "desktop-01")
	if err != nil {
		t.Fatal(err)
	}
	text := string(content)
	for _, want := range []string{
		`server_url = "wss://controller.example.test/v1/agent"`,
		`client_id = "desktop-01"`,
		`state_dir = "C:\\ProgramData\\RVBox\\data"`,
		`daemon_cwd = "C:\\Users\\Public"`,
		`listen = ""`,
	} {
		if !strings.Contains(text, want) {
			t.Fatalf("generated configuration missing %q:\n%s", want, text)
		}
	}
	if _, err := packagedClientConfig("", "desktop-01"); err == nil {
		t.Fatal("missing bootstrap URL was accepted")
	}
}

func TestInstallerClientIDNormalizesHostnames_HP_WINCLI_05(t *testing.T) {
	t.Parallel()
	if got := installerClientID("  desktop host\n"); got != "desktop-host" {
		t.Fatalf("normalized hostname = %q", got)
	}
	if got := installerClientID("\x00"); got != "rvbox-client" {
		t.Fatalf("fallback hostname = %q", got)
	}
}

func TestPublishClientTelemetrySample_HP_OPS_07(t *testing.T) {
	t.Parallel()
	health := observability.New()
	publishClientTelemetrySample(context.Background(), func(context.Context) (spool.Telemetry, error) {
		return spool.Telemetry{QueuedCommands: 2, ChargedBytes: 2048}, nil
	}, health)
	snapshot := health.MetricsSnapshot()
	if snapshot.Gauges["queue_depth"] != 2 || snapshot.Gauges["client_spool_bytes"] != 2048 {
		t.Fatalf("client telemetry gauges = %#v", snapshot.Gauges)
	}
}

func TestPublishClientTelemetrySampleFailure_BH_OPS_04(t *testing.T) {
	t.Parallel()
	health := observability.New()
	publishClientTelemetrySample(context.Background(), func(context.Context) (spool.Telemetry, error) {
		return spool.Telemetry{}, errors.New("spool unavailable")
	}, health)
	_, _, counters := health.Snapshot()
	if counters["telemetry_read_failure"] != 1 {
		t.Fatalf("telemetry failure counters = %#v", counters)
	}
}