Artifact [eeee867b78]

Artifact eeee867b787105c13d164895b81c4bb1eba34df5884279b5cb0e7305228be69f:

• File internal/fsltype/cardtime_test.go — part of check-in [d810a8118f] at 2026-10-18 20:01:53 on branch main — fix: handle time exactly as fossil does (#442)

  * fix(manifest): round a caller's check-in and tag time as fossil does

  Fossil reads a --date-override through SQLite's strftime, which rounds the seconds to the millisecond (holding a fraction past .999 in its second) rather than truncating them. A caller time finer than a millisecond now gets the D card fossil would write for it; the default clock time is still truncated, as fossil reads its clock.

  fsltype.CardTime and CardTimeNow are the one place both rules live, and the checkout commit path and branch creation take their default time through them.

  * fix(repo): stamp config and user rows in seconds since 1970

  Fossil writes config.mtime and user.mtime with its now() SQL function, time(0). SetConfig, SetHashPolicy and CreateUser wrote julianday('now') instead, so fossil read those rows as dating from 1970 when comparing times in a configuration merge, and SetCaps and SetPassword left the user's mtime alone where fossil's user command restamps it.

  * fix(auth): read and write user.cexpire as a Julian day

  Fossil keeps user.cexpire as a Julian day (src/login.c). A sync login parsed it as RFC 3339 or 'YYYY-MM-DD HH:MM:SS' text, so any value fossil had written failed to parse and the login was refused as expired. The expiry is now read through julianday(), which takes both forms, and repo invite --ttl writes a Julian day; its write error is now checked.

  * fix(checkout): set file times as fossil's --setmtime does

  Fossil's --setmtime gives each unedited file the time of the newest check-in, among the version and its primary ancestors, that recorded the file's content, truncated to whole seconds (mtime_of_manifest_file), and it does so for every unedited file of the version once the checkout is up to date (vfile_check_signature with CKSIG_SETMTIME). SetMTime gave every written file the target check-in's time to the millisecond, and an update left the files it did not write alone.

  * fix(stash): keep and show stash and bisect times as fossil does

  Fossil stores stash.ctime as julianday('now') and lists it with datetime(ctime); go-libfossil stored CURRENT_TIMESTAMP text, which the two drivers returned in different forms, and showed a fossil-written time as a bare number. bisect's list now shows datetime(event.mtime), as fossil's bisect ls does, instead of the Julian day.

  * test(verify): fossil rebuild keeps the times go-libfossil stores

  A repository go-libfossil wrote, with check-ins at caller and clock times, a tag and a branch, is rebuilt by the fossil binary, and every check-in event, plink and tagxref time must come back unchanged.

  * test(sync): a fossil clone and push agree on every synced time

  The fossil binary clones a go-libfossil server, unversioned files included, commits at a time finer than a millisecond and pushes back. Each side derives check-in event, plink and tagxref times from the artifacts itself, and the unversioned time travels on the wire; both repositories must then hold the same values.

  * fix(resolve): bound NAME:TIMESTAMP with julianday() as fossil does

  Fossil resolves BRANCH:TIMESTAMP with event.mtime<=julianday(BOUND). The bound was computed in the text form event rows hold, so on a millisecond where that form is larger than julianday()'s, a check-in at the bound itself resolved here and not in fossil.

  * fix(manifest): round a caller's card time with integer arithmetic

  CardTime followed SQLite's printing of the seconds as a double, which is not a well-defined rounding: at exact half-millisecond ties fossil 2.28's SQLite gives .124 for .1245 but .020 for .0195, and other SQLite versions differ again. A caller time is now rounded to the nearest millisecond on its nanoseconds, ties up, held at .999 as fossil holds it. The fossil binary test compares every non-tie value, across second, minute, day and year ends; ties are asserted on their own.

  * fix(auth): ignore user.cexpire at sync login, as fossil does

  user.cexpire is the expiry of fossil's web-login cookie: fossil sets it at web login, writes 0 at logout, and its sync login (check_login) never reads it. Refusing a sync login on it locked out anyone who had logged into or out of fossil's web UI, or whose cookie had lapsed.

  The invite TTL that relied on it now lives in a config row of its own, invite-expire:LOGIN, as a UTC instant checked at sync login; repo invite no longer writes cexpire, and the expiry is no longer written in local time and read as UTC. Deleting a user drops its invite expiry.

  Tracked in #441.

  * fix(repo): convert Julian config and user mtimes on open

  Repositories go-libfossil wrote before config and user rows were stamped in seconds since 1970 still hold Julian days there, which fossil reads as January 1970. Open converts those rows to the seconds they stand for. It checks first and writes only when a row needs it, so it converts once and takes no write lock on an up-to-date repository.

  * fix(checkout): set a file no check-in recorded to 1970, as fossil does

  With no mlink row for a file's artifact in the version's ancestry, fossil's max(event.mtime) is NULL, which mtime_of_manifest_file reads as 0, so --setmtime sets the file to 1970. SetMTime skipped the file.

  * fix(stash): list stashes by creation time, as fossil's stash ls does

  fossil stash ls orders by ctime, oldest first. List ordered by stash id, newest first; it now orders by ctime with the id breaking a tie.

  * fix(auth): clear a login's invite expiry with the user, atomically

  DeleteUser removed the user and its invite expiry in two statements; a failure between them left the user's expiry behind or the user without it. Both now go in one transaction. A user fossil deleted leaves its invite-expire row behind, so CreateUser clears it in the same transaction as the insert; repo invite sets its own expiry afterwards.

  The on-open conversion of Julian config and user mtimes is now best-effort: while another connection holds the write lock, Open skips it and a later open converts the rows, instead of failing. (user: [email protected], size: 3006) [annotate] [blame] [check-ins using] [more...]

package fsltype

import (
	"testing"
	"time"
)

// fossilCardTimes are D-card times the fossil 2.28 binary wrote for a given
// date, from `fossil test-date-format`: to the nearest millisecond, except
// that a fraction past .999 stays in its second.
var fossilCardTimes = []struct {
	in   time.Time
	want string
}{
	{time.Date(2026, 10, 18, 12, 34, 56, 789600000, time.UTC), "2026-10-18T12:34:56.790"},
	{time.Date(2026, 10, 18, 12, 34, 56, 789499999, time.UTC), "2026-10-18T12:34:56.789"},
	{time.Date(2026, 10, 18, 23, 59, 59, 999600000, time.UTC), "2026-10-18T23:59:59.999"},
	{time.Date(2026, 10, 18, 12, 34, 56, 0, time.UTC), "2026-10-18T12:34:56.000"},
	{time.Date(2026, 10, 18, 12, 34, 56, 123456700, time.UTC), "2026-10-18T12:34:56.123"},
}

func TestCardTimeMatchesFossil(t *testing.T) {
	for _, c := range fossilCardTimes {
		got := CardTime(c.in).Format("2006-01-02T15:04:05.000")
		if got != c.want {
			t.Errorf("CardTime(%s) = %s, fossil writes %s",
				c.in.Format(time.RFC3339Nano), got, c.want)
		}
	}
}

// A time in another zone is the same instant in UTC, as fossil reads it.
func TestCardTimeIsUTC(t *testing.T) {
	in := time.Date(2026, 10, 18, 7, 34, 56, 789600000, time.FixedZone("CDT", -5*3600))
	got := CardTime(in)
	if got.Location() != time.UTC {
		t.Fatalf("CardTime location = %v, want UTC", got.Location())
	}
	if want := time.Date(2026, 10, 18, 12, 34, 56, 790000000, time.UTC); !got.Equal(want) {
		t.Fatalf("CardTime = %v, want %v", got, want)
	}
}

// "now" is the clock to the millisecond, the rest dropped: SQLite reads the
// clock in whole milliseconds.
func TestCardTimeNowTruncates(t *testing.T) {
	now := time.Date(2026, 10, 18, 12, 34, 56, 789999999, time.UTC)
	want := time.Date(2026, 10, 18, 12, 34, 56, 789000000, time.UTC)
	if got := CardTimeNow(now); !got.Equal(want) || got.Location() != time.UTC {
		t.Fatalf("CardTimeNow(%v) = %v, want %v", now, got, want)
	}
}

// A time already on the millisecond is left alone, so the check-in path can
// apply CardTime to a CardTimeNow reading.
func TestCardTimeKeepsMilliseconds(t *testing.T) {
	base := time.Date(2026, 10, 18, 12, 34, 0, 0, time.UTC)
	for ms := 0; ms < 60000; ms++ {
		in := base.Add(time.Duration(ms) * time.Millisecond)
		if got := CardTime(in); !got.Equal(in) {
			t.Fatalf("CardTime(%v) = %v, want it unchanged", in, got)
		}
	}
}

// An exact half millisecond rounds up. Fossil's answer there depends on how
// its bundled SQLite prints a double (2.28 gives .124 for .1245 and .020 for
// .0195), so CardTime does not follow it.
func TestCardTimeRoundsTiesUp(t *testing.T) {
	for _, c := range []struct {
		nsec int
		want string
	}{
		{789500000, "12:34:56.790"},
		{124500000, "12:34:56.125"},
		{19500000, "12:34:56.020"},
		{500000, "12:34:56.001"},
		{998500000, "12:34:56.999"},
	} {
		in := time.Date(2026, 10, 18, 12, 34, 56, c.nsec, time.UTC)
		if got := CardTime(in).Format("15:04:05.000"); got != c.want {
			t.Errorf("CardTime(%d ns) = %s, want %s", c.nsec, got, c.want)
		}
	}
}