import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test"

import { ServerScope } from "./server-scope"

type PersistTestingType = typeof import("./persist").PersistTesting

type PersistType = typeof import("./persist").Persist

type RemovePersistedType = typeof import("./persist").removePersisted

class MemoryStorage implements Storage {

private values = new Map<string, string>()

readonly events: string[] = []

readonly calls = { get: 0, set: 0, remove: 0 }

clear() {

this.values.clear()

}

get length() {

return this.values.size

}

key(index: number) {

return Array.from(this.values.keys())[index] ?? null

}

getItem(key: string) {

this.calls.get += 1

this.events.push(`get:${key}`)

if (key.startsWith("opencode.throw")) throw new Error("storage get failed")

return this.values.get(key) ?? null

}

setItem(key: string, value: string) {

this.calls.set += 1

this.events.push(`set:${key}`)

if (key.startsWith("opencode.quota")) throw new DOMException("quota", "QuotaExceededError")

if (key.startsWith("opencode.throw")) throw new Error("storage set failed")

this.values.set(key, value)

}

removeItem(key: string) {

this.calls.remove += 1

this.events.push(`remove:${key}`)

if (key.startsWith("opencode.throw")) throw new Error("storage remove failed")

this.values.delete(key)

}

}

const storage = new MemoryStorage()

let persistTesting: PersistTestingType

let Persist: PersistType

let removePersisted: RemovePersistedType

beforeAll(async () => {

mock.module("@/context/platform", () => ({

usePlatform: () => ({ platform: "web" }),

}))

const mod = await import("./persist")

persistTesting = mod.PersistTesting

Persist = mod.Persist

removePersisted = mod.removePersisted

})

beforeEach(() => {

storage.clear()

storage.events.length = 0

storage.calls.get = 0

storage.calls.set = 0

storage.calls.remove = 0

Object.defineProperty(globalThis, "localStorage", {

value: storage,

configurable: true,

})

})

describe("persist localStorage resilience", () => {

test("does not cache values as persisted when quota write and eviction fail", () => {

const storageApi = persistTesting.localStorageWithPrefix("opencode.quota.scope")

storageApi.setItem("value", '{"value":1}')

expect(storage.getItem("opencode.quota.scope:value")).toBeNull()

expect(storageApi.getItem("value")).toBeNull()

})

test("disables only the failing scope when storage throws", () => {

const bad = persistTesting.localStorageWithPrefix("opencode.throw.scope")

bad.setItem("value", '{"value":1}')

const before = storage.calls.set

bad.setItem("value", '{"value":2}')

expect(storage.calls.set).toBe(before)

expect(bad.getItem("value")).toBeNull()

const healthy = persistTesting.localStorageWithPrefix("opencode.safe.scope")

healthy.setItem("value", '{"value":3}')

expect(storage.getItem("opencode.safe.scope:value")).toBe('{"value":3}')

})

test("failing fallback scope does not poison direct storage scope", () => {

const broken = persistTesting.localStorageWithPrefix("opencode.throw.scope2")

broken.setItem("value", '{"value":1}')

const direct = persistTesting.localStorageDirect()

direct.setItem("direct-value", '{"value":5}')

expect(storage.getItem("direct-value")).toBe('{"value":5}')

})

test("normalizer rejects malformed JSON payloads", () => {

const result = persistTesting.normalize({ value: "ok" }, '{"value":"\\x"}')

expect(result).toBeUndefined()

})

test("workspace storage sanitizes Windows filename characters", () => {

const result = persistTesting.workspaceStorage("C:\\Users\\foo")

expect(result).toStartWith("opencode.workspace.")

expect(result.endsWith(".dat")).toBeTrue()

expect(/[:\\/]/.test(result)).toBeFalse()

})

test("workspace target keeps raw path storage as legacy fallback", () => {

const target = Persist.workspace("C:\\Users\\foo", "vcs")

expect(target.storage).toBe(persistTesting.workspaceStorage("C:/Users/foo"))

expect(target.legacyStorageNames).toEqual([persistTesting.workspaceStorage("C:\\Users\\foo")])

})

test("workspace target keeps backslash storage as fallback for normalized Windows paths", () => {

const target = Persist.workspace("C:/Users/foo", "vcs")

expect(target.storage).toBe(persistTesting.workspaceStorage("C:/Users/foo"))

expect(target.legacyStorageNames).toEqual([persistTesting.workspaceStorage("C:\\Users\\foo")])

})

test("migrates direct legacy keys into scoped storage", () => {

storage.setItem("legacy.workspace", '{"value":2}')

const target = Persist.workspace("C:/Users/foo", "demo", ["legacy.workspace"])

const current = persistTesting.localStorageWithPrefix(target.storage!)

const legacyStore = persistTesting.localStorageDirect()

const result = persistTesting.migrateLegacy({

current,

legacyStore,

stores: [],

keys: target.legacy!,

key: target.key,

defaults: { value: 1 },

})

expect(result).toBe('{"value":2}')

expect(storage.getItem(`${target.storage}:${target.key}`)).toBe('{"value":2}')

expect(legacyStore.getItem("legacy.workspace")).toBeNull()

expect(storage.getItem("legacy.workspace")).toBeNull()

})

test("removes legacy workspace storage when removing persisted target", () => {

const target = Persist.workspace("C:\\Users\\foo", "terminal")

storage.setItem(`${target.storage}:${target.key}`, '{"value":1}')

storage.setItem(`${target.legacyStorageNames![0]}:${target.key}`, '{"value":2}')

removePersisted(target)

expect(storage.getItem(`${target.storage}:${target.key}`)).toBeNull()

expect(storage.getItem(`${target.legacyStorageNames![0]}:${target.key}`)).toBeNull()

})

test("draft target isolates storage per draft and namespaces keys", () => {

const a = Persist.draft("draft-a", "prompt")

const b = Persist.draft("draft-b", "prompt")

expect(a.key).toBe("draft:prompt")

expect(a.storage).not.toBe(b.storage)

expect(a.storage).not.toBe(Persist.workspace("/home/luke/repo", "prompt").storage)

})

test("removes draft storage when removing persisted target", () => {

const target = Persist.draft("draft-a", "prompt")

storage.setItem(`${target.storage}:${target.key}`, '{"value":1}')

removePersisted(target)

expect(storage.getItem(`${target.storage}:${target.key}`)).toBeNull()

})

test("server workspace target preserves local storage and isolates remote storage", () => {

const local = Persist.serverWorkspace(ServerScope.local, "/home/luke/repo", "prompt")

const windows = Persist.serverWorkspace("https://windows.example" as ServerScope, "/home/luke/repo", "prompt")

const debian = Persist.serverWorkspace("https://debian.example" as ServerScope, "/home/luke/repo", "prompt")

expect(local).toEqual(Persist.workspace("/home/luke/repo", "prompt"))

expect(windows.storage).not.toBe(local.storage)

expect(debian.storage).not.toBe(local.storage)

expect(debian.storage).not.toBe(windows.storage)

expect(windows.legacyStorageNames).toBeUndefined()

expect(debian.legacyStorageNames).toBeUndefined()

})

test("server global target preserves local key and isolates remote keys", () => {

expect(Persist.serverGlobal(ServerScope.local, "notification")).toEqual(Persist.global("notification"))

expect(Persist.serverGlobal("https://debian.example" as ServerScope, "notification")).toEqual({

storage: "opencode.global.dat",

key: "https://debian.example\0notification",

})

})

test("server global target cannot collide when scope and key contain colons", () => {

expect(Persist.serverGlobal("a:b" as ServerScope, "c")).not.toEqual(Persist.serverGlobal("a" as ServerScope, "b:c"))

})

})