fleetd/bridged/src/test/java/dev/ltms/bridged/member/OpenCodeSessionDiscoveryTest.java

package dev.ltms.bridged.member;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.FileTime;

import static org.junit.jupiter.api.Assertions.*;

/**
 * {@link OpenCodeSessionDiscovery} matches an opencode session record by the worker's cwd (its
 * {@code directory}) against opencode's on-disk storage. These tests populate a TEMP storage root
 * themselves — never the operator's real {@code ~/.local/share/opencode}.
 */
class OpenCodeSessionDiscoveryTest {

    /**
     * Write a session record {@code {"id":..., "directory":...}} under
     * {@code <root>/session/<projectID>/<fileName>} and stamp it with a known last-modified time,
     * so "most recently modified wins" is deterministic. Static so the launcher test can reuse it.
     */
    static void writeRecord(Path root, String projectId, String fileName, String id,
                            String directory, long lastModifiedEpochMillis) throws Exception {
        Path dir = root.resolve("session").resolve(projectId);
        Files.createDirectories(dir);
        Path file = dir.resolve(fileName);
        Files.writeString(file, "{\"id\":\"" + id + "\",\"directory\":\"" + directory
                + "\",\"projectID\":\"" + projectId + "\",\"version\":\"1.1.31\"}");
        Files.setLastModifiedTime(file, FileTime.fromMillis(lastModifiedEpochMillis));
    }

    @Test
    void findsTheRecordWhoseDirectoryEqualsTheCwd(@TempDir Path root) throws Exception {
        writeRecord(root, "p1", "ses_a.json", "ses_aaa", "/w/a", 1000L);
        writeRecord(root, "p2", "ses_b.json", "ses_bbb", "/w/b", 2000L);

        assertEquals("ses_bbb", new OpenCodeSessionDiscovery(root).sessionIdForDirectory("/w/b"),
                "the record whose directory equals the cwd is the one found");
        assertEquals("ses_aaa", new OpenCodeSessionDiscovery(root).sessionIdForDirectory("/w/a"));
    }

    @Test
    void aNonMatchingDirectoryYieldsNullRatherThanAMismatch(@TempDir Path root) throws Exception {
        writeRecord(root, "p1", "ses_a.json", "ses_aaa", "/w/a", 1000L);

        assertNull(new OpenCodeSessionDiscovery(root).sessionIdForDirectory("/w/other"),
                "no record for this cwd yet → null, not a wrong session");
    }

    @Test
    void prefersTheMostRecentlyModifiedRecordWhenSeveralMatch(@TempDir Path root) throws Exception {
        writeRecord(root, "p1", "old.json", "ses_old", "/w/a", 1000L);
        writeRecord(root, "p2", "new.json", "ses_new", "/w/a", 5000L);

        assertEquals("ses_new", new OpenCodeSessionDiscovery(root).sessionIdForDirectory("/w/a"),
                "the freshest record for the cwd wins");
    }

    @Test
    void aMissingOrEmptyStorageRootYieldsNullWithoutThrowing(@TempDir Path root) throws Exception {
        // Missing: no session dir at all under the root.
        assertNull(new OpenCodeSessionDiscovery(root).sessionIdForDirectory("/w/a"));

        // Present but empty: a session dir with nothing in it produces no match, not a throw.
        Path emptyRoot = root.resolve("empty");
        Files.createDirectories(emptyRoot.resolve("session"));
        assertNull(new OpenCodeSessionDiscovery(emptyRoot).sessionIdForDirectory("/w/a"));
    }

    @Test
    void aBlankOrNullDirectoryYieldsNull(@TempDir Path root) {
        OpenCodeSessionDiscovery discovery = new OpenCodeSessionDiscovery(root);
        assertNull(discovery.sessionIdForDirectory(null));
        assertNull(discovery.sessionIdForDirectory("   "));
    }

    @Test
    void aMalformedRecordIsSkippedRatherThanFatal(@TempDir Path root) throws Exception {
        // A record that fails to parse must not abort the scan of its siblings.
        Path dir = root.resolve("session").resolve("p1");
        Files.createDirectories(dir);
        Files.writeString(dir.resolve("broken.json"), "{not valid json");
        writeRecord(root, "p1", "good.json", "ses_good", "/w/a", 1000L);

        assertEquals("ses_good", new OpenCodeSessionDiscovery(root).sessionIdForDirectory("/w/a"),
                "an unreadable record is skipped; a later valid one still matches");
    }
}