mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Copy mode previously computed DirChecksum (Walk + ReadFile + SHA256) for every skill on every sync, even when nothing changed. Add mtime- based short-circuit: if source dir max mtime matches the manifest record, skip checksum entirely. Changes: - Add DirMaxMtime() — Walk + lstat only, no file reads - Extend Manifest with Mtimes map (omitempty, backward-compatible) - SyncTargetCopyWithSkills: mtime fast-path with target validity check - diff: two-phase scan-then-display with spinner (no more interleaved spinner + diff output), discovery spinner for both global/project - Clearer diff reasons: "missing" → "source only", "missing (deleted from target)" → "deleted from target" - Server handleDiff: same mtime fast-path for copy mode - Prune cleans up orphan mtime entries
151 lines
3.6 KiB
Go
151 lines
3.6 KiB
Go
package sync
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
func TestReadManifest_NotExist(t *testing.T) {
|
|
m, err := ReadManifest("/nonexistent/path")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m == nil {
|
|
t.Fatal("expected non-nil manifest")
|
|
}
|
|
if len(m.Managed) != 0 {
|
|
t.Errorf("expected empty Managed map, got %d entries", len(m.Managed))
|
|
}
|
|
}
|
|
|
|
func TestReadManifest_CorruptJSON(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, ManifestFile), []byte("{invalid json"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
m, err := ReadManifest(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m == nil {
|
|
t.Fatal("expected non-nil manifest for corrupt JSON")
|
|
}
|
|
if len(m.Managed) != 0 {
|
|
t.Errorf("expected empty Managed map for corrupt JSON, got %d entries", len(m.Managed))
|
|
}
|
|
}
|
|
|
|
func TestWriteReadManifest_Roundtrip(t *testing.T) {
|
|
dir := t.TempDir()
|
|
original := &Manifest{
|
|
Managed: map[string]string{
|
|
"skill-a": "abc123",
|
|
"skill-b": "def456",
|
|
},
|
|
}
|
|
|
|
if err := WriteManifest(dir, original); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
loaded, err := ReadManifest(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(loaded.Managed) != 2 {
|
|
t.Fatalf("expected 2 managed entries, got %d", len(loaded.Managed))
|
|
}
|
|
if loaded.Managed["skill-a"] != "abc123" {
|
|
t.Errorf("expected checksum 'abc123', got %q", loaded.Managed["skill-a"])
|
|
}
|
|
if loaded.Managed["skill-b"] != "def456" {
|
|
t.Errorf("expected checksum 'def456', got %q", loaded.Managed["skill-b"])
|
|
}
|
|
if loaded.UpdatedAt.IsZero() {
|
|
t.Error("expected non-zero UpdatedAt")
|
|
}
|
|
|
|
// Verify file is valid JSON
|
|
data, err := os.ReadFile(filepath.Join(dir, ManifestFile))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var check map[string]any
|
|
if err := json.Unmarshal(data, &check); err != nil {
|
|
t.Errorf("manifest file is not valid JSON: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestWriteReadManifest_MtimesRoundtrip(t *testing.T) {
|
|
dir := t.TempDir()
|
|
original := &Manifest{
|
|
Managed: map[string]string{
|
|
"skill-a": "abc123",
|
|
},
|
|
Mtimes: map[string]int64{
|
|
"skill-a": 1718449200000000000, // some UnixNano
|
|
},
|
|
}
|
|
|
|
if err := WriteManifest(dir, original); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
loaded, err := ReadManifest(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if loaded.Mtimes["skill-a"] != 1718449200000000000 {
|
|
t.Errorf("expected mtime 1718449200000000000, got %d", loaded.Mtimes["skill-a"])
|
|
}
|
|
}
|
|
|
|
func TestReadManifest_OldFormat_NoMtimes(t *testing.T) {
|
|
dir := t.TempDir()
|
|
// Simulate old manifest without mtimes field
|
|
data := []byte(`{"managed":{"skill-a":"abc123"},"updated_at":"2025-01-01T00:00:00Z"}`)
|
|
if err := os.WriteFile(filepath.Join(dir, ManifestFile), data, 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
loaded, err := ReadManifest(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if loaded.Mtimes == nil {
|
|
t.Fatal("Mtimes should be initialized even for old format")
|
|
}
|
|
if len(loaded.Mtimes) != 0 {
|
|
t.Errorf("expected empty Mtimes for old format, got %d entries", len(loaded.Mtimes))
|
|
}
|
|
if loaded.Managed["skill-a"] != "abc123" {
|
|
t.Error("Managed should still work with old format")
|
|
}
|
|
}
|
|
|
|
func TestRemoveManifest(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Write then remove
|
|
original := &Manifest{Managed: map[string]string{"x": "y"}}
|
|
if err := WriteManifest(dir, original); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := RemoveManifest(dir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Verify file is gone
|
|
if _, err := os.Stat(filepath.Join(dir, ManifestFile)); !os.IsNotExist(err) {
|
|
t.Error("expected manifest file to be removed")
|
|
}
|
|
|
|
// Removing again should be a no-op
|
|
if err := RemoveManifest(dir); err != nil {
|
|
t.Errorf("removing non-existent manifest should not error: %v", err)
|
|
}
|
|
}
|