clerk @ 1b9e6e1f8922a34b89b80ea1c5b55997326c3aa5

package lsp

import (

	"context"

	"path/filepath"

	"slices"

	"strings"

	"sync"

	"testing"

	"go.lsp.dev/protocol"

	"go.lsp.dev/uri"

	"olexsmir.xyz/clerk/internal/linter"

	"olexsmir.xyz/clerk/internal/testutil"

)

func TestAnalysisFor_CachedAndRebuilt(t *testing.T) {

	u := uri.File(filepath.Join(t.TempDir(), "a.journal"))

	srv := newServer(t)

	srv.server.openDoc(u, "2024-01-01 t\n    expenses:food  $10\n    assets:cash\n", 1, "journal")

	a1 := srv.server.analysisFor(u)

	if a1 == nil {

		t.Fatal("analysisFor returned nil")

	}

	if a2 := srv.server.analysisFor(u); a2 != a1 {

		t.Error("cached analysis not reused")

	}

	srv.server.updateDoc(u, 2, []protocol.TextDocumentContentChangeEvent{

		&protocol.TextDocumentContentChangeWholeDocument{Text: "2024-01-02 t\n    expenses:travel  $20\n    assets:cash\n"},

	})

	a3 := srv.server.analysisFor(u)

	if a3 == a1 {

		t.Error("edit did not rebuild the analysis")

	}

	if !slices.Contains(a3.AccountNames, "expenses:travel") || slices.Contains(a3.AccountNames, "expenses:food") {

		t.Errorf("stale accounts after edit: %v", a3.AccountNames)

	}

}

func TestAnalysisFor_DependentDirty(t *testing.T) {

	dir := t.TempDir()

	base := filepath.Join(dir, "base.journal")

	main := filepath.Join(dir, "main.journal")

	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:cash\n"))

	testutil.WriteFile(t, main, []byte("include base.journal\n"))

	srv := newServer(t)

	uMain, uBase := uri.File(main), uri.File(base)

	srv.server.openDoc(uMain, "include base.journal\n", 1, "journal")

	srv.server.openDoc(uBase, "2024-01-01 t\n    expenses:food  $10\n    assets:cash\n", 1, "journal")

	aMain := srv.server.analysisFor(uMain)

	if !slices.Contains(aMain.AccountNames, "assets:cash") {

		t.Fatalf("main analysis missing included account: %v", aMain.AccountNames)

	}

	srv.server.updateDoc(uBase, 2, []protocol.TextDocumentContentChangeEvent{

		&protocol.TextDocumentContentChangeWholeDocument{Text: "2024-01-01 t\n    expenses:food  $10\n    assets:bank\n"},

	})

	aMain2 := srv.server.analysisFor(uMain)

	if !slices.Contains(aMain2.AccountNames, "assets:bank") {

		t.Errorf("dependent analysis not rebuilt with new buffer content: %v", aMain2.AccountNames)

	}

}

func TestServer_Diagnostics(t *testing.T) {

	dir := t.TempDir()

	a := uri.File(filepath.Join(dir, "a.journal"))

	b := uri.File(filepath.Join(dir, "b.journal"))

	aContent := "account expenses:food\naccount assets:cash\ncommodity $\npayee test\n\n2024-01-01 * test\n    expenses:food  $10.00\n    assets:cash  $5.00\n"

	bContent := "include a.journal\n"

	testutil.WriteFile(t, a.Path(), []byte(aContent))

	testutil.WriteFile(t, b.Path(), []byte(bContent))

	srv := newServer(t)

	capture := &captureClient{}

	srv.server.client = capture

	open := func(u uri.URI, content string) {

		t.Helper()

		if err := srv.server.DidOpen(t.Context(), &protocol.DidOpenTextDocumentParams{

			TextDocument: protocol.TextDocumentItem{URI: u, LanguageID: "journal", Version: 1, Text: content},

		}); err != nil {

			t.Fatalf("didOpen %s: %v", u, err)

		}

	}

	open(a, aContent)

	open(b, bContent)

	// publishDiagnostics is invoked directly so the test is deterministic: the

	// didOpen/didChange handlers debounce publishing by 200ms in production.

	srv.server.publishDiagnostics(t.Context())

	da, _ := capture.lastDiags(a)

	if len(da) == 0 {

		t.Fatal("expected diagnostics for the unbalanced transaction")

	}

	aEdited := "account expenses:food\naccount assets:cash\naccount assets:bank\ncommodity $\npayee test\n\n2024-01-01 * test\n    expenses:food  $20.00\n    assets:cash  $-10.00\n    assets:bank  $-10.00\n"

	if err := srv.server.DidChange(t.Context(), &protocol.DidChangeTextDocumentParams{

		TextDocument: protocol.VersionedTextDocumentIdentifier{

			TextDocumentIdentifier: protocol.TextDocumentIdentifier{URI: a},

			Version:                2,

		},

		ContentChanges: []protocol.TextDocumentContentChangeEvent{

			&protocol.TextDocumentContentChangeWholeDocument{Text: aEdited},

		},

	}); err != nil {

		t.Fatalf("didChange a: %v", err)

	}

	srv.server.publishDiagnostics(t.Context())

	if da, _ := capture.lastDiags(a); len(da) != 0 {

		t.Errorf("diagnostics not cleared after the edit: %v", da)

	}

	if err := srv.server.DidClose(t.Context(), &protocol.DidCloseTextDocumentParams{

		TextDocument: protocol.TextDocumentIdentifier{URI: a},

	}); err != nil {

		t.Fatalf("didClose a: %v", err)

	}

	if da, _ := capture.lastDiags(a); len(da) != 0 {

		t.Errorf("diagnostics not cleared on close: %v", da)

	}

}

func TestServer_DidChangeWatchedFiles_SkipsOpenDocuments(t *testing.T) {

	dir := t.TempDir()

	base := filepath.Join(dir, "base.journal")

	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:cash\n"))

	srv := newServer(t)

	uBase := uri.File(base)

	srv.server.openDoc(uBase, "2024-01-01 t\n    expenses:food  $10\n    assets:cash\n", 1, "journal")

	a1 := srv.server.analysisFor(uBase)

	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:bank\n"))

	if err := srv.server.DidChangeWatchedFiles(t.Context(), &protocol.DidChangeWatchedFilesParams{

		Changes: []protocol.FileEvent{{URI: uBase, Type: protocol.FileChangeTypeChanged}},

	}); err != nil {

		t.Fatalf("didChangeWatchedFiles: %v", err)

	}

	if a2 := srv.server.analysisFor(uBase); a2 != a1 {

		t.Error("open document rebuilt from disk; buffer is authoritative")

	}

}

func TestServer_DidChangeWatchedFiles_DiskChangeDirtiesDependents(t *testing.T) {

	dir := t.TempDir()

	base := filepath.Join(dir, "base.journal")

	main := filepath.Join(dir, "main.journal")

	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:cash\n"))

	testutil.WriteFile(t, main, []byte("include base.journal\n"))

	srv := newServer(t)

	srv.server.client = &captureClient{}

	uMain := uri.File(main)

	if err := srv.server.DidOpen(t.Context(), &protocol.DidOpenTextDocumentParams{

		TextDocument: protocol.TextDocumentItem{URI: uMain, LanguageID: "journal", Version: 1, Text: "include base.journal\n"},

	}); err != nil {

		t.Fatalf("didOpen: %v", err)

	}

	a1 := srv.server.analysisFor(uMain)

	if !slices.Contains(a1.AccountNames, "assets:cash") {

		t.Fatalf("initial analysis missing included account: %v", a1.AccountNames)

	}

	// base changes on disk, outside the editor

	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:bank\n"))

	if err := srv.server.DidChangeWatchedFiles(t.Context(), &protocol.DidChangeWatchedFilesParams{

		Changes: []protocol.FileEvent{{URI: uri.File(base), Type: protocol.FileChangeTypeChanged}},

	}); err != nil {

		t.Fatalf("didChangeWatchedFiles: %v", err)

	}

	a2 := srv.server.analysisFor(uMain)

	if a2 == a1 {

		t.Error("disk change did not rebuild the dependent analysis")

	}

	if !slices.Contains(a2.AccountNames, "assets:bank") {

		t.Errorf("stale included content after disk change: %v", a2.AccountNames)

	}

}

func TestServer_ReportsConfigProblems(t *testing.T) {

	for name, tt := range map[string]struct {

		config, inline string

		typ            protocol.MessageType

		want           string

	}{

		"unknown setting":            {config: "bogus = 1\n", typ: protocol.MessageTypeWarning, want: `unknown setting "bogus"`},

		"unknown lint rule":          {config: "[lint]\nnot-a-rule = \"error\"\n", typ: protocol.MessageTypeWarning, want: `unknown lint rule "not-a-rule"`},

		"unparseable":                {config: "not toml [[[\n", typ: protocol.MessageTypeError, want: "toml:"},

		"settings unknown lint rule": {inline: `{"lint":{"unused_accountt":"off"}}`, typ: protocol.MessageTypeWarning, want: `unknown lint rule "unused_accountt"`},

	} {

		t.Run(name, func(t *testing.T) {

			capture := &captureClient{}

			var srv *server

			if tt.config != "" {

				cfgPath := filepath.Join(t.TempDir(), "clerk.toml")

				testutil.WriteFile(t, cfgPath, []byte(tt.config))

				s, err := NewServer("test", cfgPath)

				if err != nil {

					t.Fatal(err)

				}

				srv = s.server

				srv.client = capture

				if err := srv.Initialized(t.Context(), &protocol.InitializedParams{}); err != nil {

					t.Fatalf("initialized: %v", err)

				}

			} else {

				srv = newServer(t).server

				srv.client = capture

				if err := srv.DidChangeConfiguration(t.Context(), &protocol.DidChangeConfigurationParams{

					Settings: protocol.LSPAny(tt.inline),

				}); err != nil {

					t.Fatalf("didChangeConfiguration: %v", err)

				}

			}

			msgs := capture.shownMessages()

			if len(msgs) != 1 || msgs[0].Type != tt.typ || !strings.Contains(msgs[0].Message, tt.want) {

				t.Errorf("unexpected messages: %+v", msgs)

			}

		})

	}

}

func TestServer_Initialized_mergesConfigWithLSPSettings(t *testing.T) {

	cfgPath := filepath.Join(t.TempDir(), "clerk.toml")

	testutil.WriteFile(t, cfgPath, []byte("[lint]\nunbalanced-transaction = \"off\"\n"))

	s, err := NewServer("test", cfgPath)

	if err != nil {

		t.Fatal(err)

	}

	if _, err := s.server.Initialize(t.Context(), &protocol.InitializeParams{

		InitializationOptions: protocol.LSPAny(`{"lint": {"missing-payee": "warn"}}`),

	}); err != nil {

		t.Fatalf("initialize: %v", err)

	}

	if err := s.server.Initialized(t.Context(), &protocol.InitializedParams{}); err != nil {

		t.Fatalf("initialized: %v", err)

	}

	s.server.mu.RLock()

	got := s.server.settings

	s.server.mu.RUnlock()

	if !got.Linter.Rules[linter.UnbalancedTransactionID].Disabled {

		t.Error("file setting unbalanced-transaction=off not applied")

	}

	if rc := got.Linter.Rules[linter.MissingPayeeID]; rc.Disabled || rc.Severity != linter.SeverityWarning {

		t.Errorf("init option missing-payee=warn clobbered by file: %+v", rc)

	}

}

type captureClient struct {

	protocol.Client

	mu    sync.Mutex

	diag  []protocol.PublishDiagnosticsParams

	shown []protocol.ShowMessageParams

}

func (c *captureClient) PublishDiagnostics(_ context.Context, params *protocol.PublishDiagnosticsParams) error {

	c.mu.Lock()

	c.diag = append(c.diag, *params)

	c.mu.Unlock()

	return nil

}

func (c *captureClient) ShowMessage(_ context.Context, params *protocol.ShowMessageParams) error {

	c.mu.Lock()

	c.shown = append(c.shown, *params)

	c.mu.Unlock()

	return nil

}

func (c *captureClient) shownMessages() []protocol.ShowMessageParams {

	c.mu.Lock()

	defer c.mu.Unlock()

	return slices.Clone(c.shown)

}

func (c *captureClient) lastDiags(u uri.URI) ([]protocol.Diagnostic, bool) {

	c.mu.Lock()

	defer c.mu.Unlock()

	for _, v := range slices.Backward(c.diag) {

		if v.URI == u {

			return v.Diagnostics, true

		}

	}

	return nil, false

}

func newServer(tb testing.TB) Server {

	tb.Helper()

	s, err := NewServer("test", filepath.Join(tb.TempDir(), "clerk.toml"))

	if err != nil {

		tb.Fatal(err)

	}

	return s

}