Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
20 commits
Select commit Hold shift + click to select a range
4944011
test(backup): refuse untracked import into another game's owned roots
Seagulls Oct 30, 2026
7b1dae1
fix(backup): admit untracked import before mutating owned save paths
Seagulls Oct 30, 2026
00dc8e1
fix(backup): admit untracked import before mutating owned save paths
Seagulls Oct 30, 2026
459d0e9
fix(backup): admit untracked import before mutating owned save paths
Seagulls Oct 30, 2026
ea577d5
fix(store): hold cross-process import claim through authoritative reg…
Seagulls Oct 30, 2026
19a6815
test(store): prove cross-process import ownership and lease identity
Seagulls Oct 30, 2026
8d8f9c8
test(store): prove cross-process import ownership and lease identity
Seagulls Oct 30, 2026
bae69ca
test(store): prove cross-process import ownership and lease identity
Seagulls Oct 30, 2026
ec7ef2c
test(store): prove cross-process import ownership and lease identity
Seagulls Oct 30, 2026
e7151ca
fix(daemon): register imported game under held native ownership admis…
Seagulls Oct 30, 2026
e656c46
fix(windows): pin named mutex ownership to one OS thread across impor…
Seagulls Oct 30, 2026
248c6e2
test(windows): prove non-recursive admission and release from other g…
Seagulls Oct 30, 2026
3db31bb
fix(backup): reconcile import admission with merged upstream ownershi…
Nov 2, 2026
913f79b
test(backup): prove HTTP rollback after registration failure
Nov 2, 2026
cc685d7
fix(store): isolate import claims and bound registration waits
Nov 7, 2026
f2a341e
Merge pull request #27 from Seagulls/fix/pr141-sidecar-bounded-wait
Seagulls Nov 7, 2026
02859f6
chore: remove supplementary import admission documentation
Nov 7, 2026
a9e7045
fix(store): reserve import claim only for path changes
Nov 9, 2026
0fe57b4
test(store): keep metadata writable during import admission
Nov 9, 2026
9435e80
Merge pull request #28 from Seagulls/fix/pr141-metadata-admission-202…
Seagulls Nov 9, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
189 changes: 189 additions & 0 deletions internal/api/backup_import_ownership_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,189 @@
package api

import (
"database/sql"
"errors"
"github.com/opensave/opensave/internal/store"
"net/http"
"os"
"path/filepath"
"testing"
)

// Reproduces the three independent native stock data-loss cases from issue
// #68 with only disposable HTTP server, SQLite, archive and save files.
func TestBackupImportCannotOverwriteAnotherGamesOwnedPath(t *testing.T) {
cases := []struct{ name, kind string }{
{"owned-primary-exact", "primary"},
{"owned-named-root-exact", "named"},
{"inside-owned-named-root", "nested"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
ts := startTestServer(t)
root := filepath.Join(t.TempDir(), "synthetic-owned-root")
target := root
if tc.kind == "nested" {
target = filepath.Join(root, "nested-save")
}
if err := os.MkdirAll(target, 0700); err != nil {
t.Fatal(err)
}
save := filepath.Join(target, "slot.sav")
if err := os.WriteFile(save, []byte("ARCHIVED-OLD-SAVE"), 0600); err != nil {
t.Fatal(err)
}
archive := exportV2(t, ts, []map[string]string{{"id": "untracked-imported", "name": "Untracked Imported", "savePath": target}})
ownerPath := ts.saveDir
if tc.kind == "primary" {
ownerPath = root
}
resp, body := ts.do(t, http.MethodPost, "/api/games", map[string]string{"name": "Existing Owner", "savePath": ownerPath})
if resp.StatusCode != http.StatusOK {
t.Fatalf("owner setup HTTP %d: %v", resp.StatusCode, body)
}
waitInitialSnapshot(t, ts, "existing-owner")
if tc.kind != "primary" {
resp, body = ts.do(t, http.MethodPost, "/api/games/existing-owner/roots", map[string]string{"name": "config", "path": root})
if resp.StatusCode != http.StatusOK {
t.Fatalf("named-root setup HTTP %d: %v", resp.StatusCode, body)
}
}
if err := os.WriteFile(save, []byte("OWNER-LIVE-PROTECTED"), 0600); err != nil {
t.Fatal(err)
}
resp, body = ts.do(t, http.MethodPost, "/api/backup/restore", map[string]string{"sourcePath": archive, "mode": "overwrite"})
after, err := os.ReadFile(save)
if err != nil {
t.Fatalf("owner save missing after backup import: %v", err)
}
t.Logf("native import scenario=%s status=%d response=%v bytes=%q", tc.name, resp.StatusCode, body, after)
if string(after) != "OWNER-LIVE-PROTECTED" {
t.Fatalf("import overwrote another game's live save: %q", after)
}
if _, err := ts.daemon.Store.GetGame("untracked-imported"); err == nil {
t.Fatal("conflicting imported game was registered")
}
})
}
}

func TestBackupImportRefusesOverwriteWhenSafetyDirectoryUnavailable(t *testing.T) {
ts := startTestServer(t)
target := filepath.Join(t.TempDir(), "backup-import-destination")
if err := os.MkdirAll(target, 0700); err != nil {
t.Fatal(err)
}
slot := filepath.Join(target, "slot.sav")
if err := os.WriteFile(slot, []byte("ARCHIVED-OLD"), 0600); err != nil {
t.Fatal(err)
}
archive := exportV2(t, ts, []map[string]string{{"id": "untracked-safety-failure", "name": "Untracked", "savePath": target}})
if err := os.WriteFile(slot, []byte("KEEP-LIVE"), 0600); err != nil {
t.Fatal(err)
}
settings, err := ts.daemon.Store.GetSettings()
if err != nil {
t.Fatal(err)
}
blockedSafety := filepath.Join(settings.BackupsDir, "_import-safety")
if err := os.WriteFile(blockedSafety, []byte("NOT-A-DIRECTORY"), 0600); err != nil {
t.Fatal(err)
}
resp, body := ts.do(t, http.MethodPost, "/api/backup/restore", map[string]string{"sourcePath": archive, "mode": "overwrite"})
got, err := os.ReadFile(slot)
if err != nil {
t.Fatal(err)
}
t.Logf("safety folder unavailable: HTTP=%d response=%v live=%q", resp.StatusCode, body, got)
if string(got) != "KEEP-LIVE" {
t.Fatalf("import overwrote live save without safety backup: %q", got)
}
if _, err := ts.daemon.Store.GetGame("untracked-safety-failure"); err == nil {
t.Fatal("unsafe import tracked")
}
}

func TestRestoreEmptyImportTarget(t *testing.T) {
t.Run("previously absent", func(t *testing.T) {
target := filepath.Join(t.TempDir(), "new-root")
if err := os.MkdirAll(filepath.Join(target, "nested"), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(target, "nested", "partial.sav"), []byte("partial"), 0600); err != nil {
t.Fatal(err)
}
if err := restoreEmptyImportTarget(target, false); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(target); !os.IsNotExist(err) {
t.Fatalf("new partial root remains: %v", err)
}
})
t.Run("existing empty directory", func(t *testing.T) {
target := filepath.Join(t.TempDir(), "existing-root")
if err := os.Mkdir(target, 0700); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Join(target, "nested"), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(target, "nested", "partial.sav"), []byte("partial"), 0600); err != nil {
t.Fatal(err)
}
if err := restoreEmptyImportTarget(target, true); err != nil {
t.Fatal(err)
}
items, err := os.ReadDir(target)
if err != nil || len(items) != 0 {
t.Fatalf("original empty directory not restored: %v %v", items, err)
}
})
}

// A real SQLite trigger rejects registration only after extraction has run.
// This exercises the HTTP recovery path without a production fault hook.
func TestBackupImportRegistrationFailureRecoversPreviousFiles(t *testing.T) {
ts := startTestServer(t)
target := filepath.Join(t.TempDir(), "untracked-root")
if err := os.MkdirAll(target, 0700); err != nil {
t.Fatal(err)
}
slot := filepath.Join(target, "slot.sav")
if err := os.WriteFile(slot, []byte("ARCHIVED"), 0600); err != nil {
t.Fatal(err)
}
archive := exportV2(t, ts, []map[string]string{{"id": "failed-import", "name": "Failed Import", "savePath": target}})
if err := os.WriteFile(slot, []byte("ORIGINAL-LIVE"), 0600); err != nil {
t.Fatal(err)
}
extra := filepath.Join(target, "original-only.sav")
if err := os.WriteFile(extra, []byte("KEEP"), 0600); err != nil {
t.Fatal(err)
}
db, err := sql.Open("sqlite", ts.daemon.Paths.SQLiteDB)
if err != nil {
t.Fatal(err)
}
defer db.Close()
if _, err := db.Exec(`CREATE TRIGGER reject_import BEFORE INSERT ON games WHEN NEW.id = 'failed-import' BEGIN SELECT RAISE(ABORT, 'injected registration failure'); END`); err != nil {
t.Fatal(err)
}
resp, body := ts.do(t, http.MethodPost, "/api/backup/restore", map[string]string{"sourcePath": archive, "mode": "overwrite"})
if resp.StatusCode != http.StatusOK || string(body["restored"]) != "0" {
t.Fatalf("unexpected import result: %d %v", resp.StatusCode, body)
}
for path, want := range map[string]string{slot: "ORIGINAL-LIVE", extra: "KEEP"} {
got, err := os.ReadFile(path)
if err != nil || string(got) != want {
t.Fatalf("recovery %s = %q, %v", filepath.Base(path), got, err)
}
}
if _, err := ts.daemon.Store.GetGame("failed-import"); !errors.Is(err, store.ErrNotFound) {
t.Fatalf("failed import registered: %v", err)
}
// A new ordinary registration proves the import claim was released.
if err := ts.daemon.Store.CreateGame(store.Game{ID: "after-failure", Name: "After", SavePath: target}); err != nil {
t.Fatalf("claim leaked: %v", err)
}
}
68 changes: 68 additions & 0 deletions internal/api/registration_claim_wait_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,68 @@
package api

import (
"bytes"
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"path/filepath"
"testing"
"time"

"github.com/opensave/opensave/internal/store"
)

// Exercise the interactive handler through daemon registration, not just the
// Store waiter: cancellation must not become a delayed successful mutation.
func TestRegistrationClaimHandlerWaitAndCancellation(t *testing.T) {
for _, cancelled := range []bool{false, true} {
name := "drains"
if cancelled {
name = "cancelled"
}
t.Run(name, func(t *testing.T) {
ts := startTestServer(t)
a, err := ts.daemon.Store.BeginImportPath(filepath.Join(t.TempDir(), "import"), "incoming")
if err != nil {
t.Fatal(err)
}
defer a.Release()
body, _ := json.Marshal(map[string]string{"name": "Claim Wait", "savePath": ts.saveDir})
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
req := httptest.NewRequest(http.MethodPost, "/api/games", bytes.NewReader(body)).WithContext(ctx)
response := httptest.NewRecorder()
done := make(chan struct{})
go func() { ts.server.handleTrackGame(response, req); close(done) }()
select {
case <-done:
t.Fatalf("handler refused without waiting: %d %s", response.Code, response.Body)
case <-time.After(60 * time.Millisecond):
}
if cancelled {
cancel()
} else {
a.Release()
}
select {
case <-done:
case <-time.After(2 * time.Second):
t.Fatal("handler did not finish")
}
a.Release()
_, err = ts.daemon.Store.FindGameBySavePath(ts.saveDir)
if cancelled {
if !errors.Is(err, store.ErrNotFound) {
t.Fatalf("cancelled request registered game: %v", err)
}
if response.Code != http.StatusConflict {
t.Fatalf("busy cancellation HTTP %d: %s", response.Code, response.Body)
}
} else if err != nil || response.Code != http.StatusOK {
t.Fatalf("drained request HTTP %d, game error %v: %s", response.Code, err, response.Body)
}
})
}
}
8 changes: 4 additions & 4 deletions internal/api/routes.go
Original file line number Diff line number Diff line change
Expand Up @@ -374,12 +374,12 @@ func (s *Server) handleTrackGame(w http.ResponseWriter, r *http.Request) {
return
}

game, err := s.Daemon.TrackGame(store.Game{Name: body.Name, SavePath: body.SavePath, AppID: body.AppID, ExePath: body.ExePath})
game, err := s.Daemon.TrackGameContext(r.Context(), store.Game{Name: body.Name, SavePath: body.SavePath, AppID: body.AppID, ExePath: body.ExePath})
if err != nil {
// Duplicates (id or path) are conflicts; anything else the daemon
// rejects is bad input.
status := http.StatusBadRequest
if errors.Is(err, store.ErrGamePathOwned) || errors.Is(err, store.ErrOwnershipClaimsChanged) ||
if errors.Is(err, store.ErrGamePathOwned) || errors.Is(err, store.ErrPathClaimBusy) || errors.Is(err, store.ErrOwnershipClaimsChanged) ||
strings.Contains(err.Error(), "already track") ||
strings.Contains(err.Error(), "already exists") {
status = http.StatusConflict
Expand Down Expand Up @@ -503,9 +503,9 @@ func (s *Server) handleUpdateGame(w http.ResponseWriter, r *http.Request) {
}
defer done()
}
if err := s.Daemon.Store.UpdateGame(game); err != nil {
if err := s.Daemon.Store.UpdateGameContext(r.Context(), game); err != nil {
status := notFoundToStatus(err)
if errors.Is(err, store.ErrOwnershipClaimsChanged) || errors.Is(err, store.ErrGamePathOwned) {
if errors.Is(err, store.ErrPathClaimBusy) || errors.Is(err, store.ErrOwnershipClaimsChanged) || errors.Is(err, store.ErrGamePathOwned) {
status = http.StatusConflict
}
writeError(w, status, err.Error())
Expand Down
Loading
Loading