Keep your own stories in a private archive

Android half of ios#54. Expired stories were gone from the author's device too, so there was no way to look back at what you posted. 🔴 This keeps something the interface told everybody would disappear, so the shape of the feature is the argument for it being acceptable: off unless switched on, labelled as what it is, and only ever holding stories this account posted. `Vault.archive` refuses anything else — the caller filters too, and this is the guard that survives the caller being rewritten. 🔴 The archive is deliberately NOT written through `saveStories`. Everything in it is expired by definition, and that path drops expired stories on write — so reusing it would empty the archive on the next pass. Separate record, and a test named for exactly that. Archiving happens in `stories()`, before `saveStories` drops the expired ones: the only moment they can be caught, since expired bytes leave on write. That runs on every load, so the fold is idempotent. ⚠️ The setting is injected into `Session` as a lambda. The engine layer has no Android dependency and must not read preferences, and an absent value has to read as OFF. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-09-02 17:47:44 -04:00
parent ddd280092e
commit 242391119b
7 changed files with 307 additions and 7 deletions
@@ -0,0 +1,93 @@
+package io.flamenet.e2e
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * A private archive of your own stories (ios#54).
+ *
+ * 🔴 **This keeps something the interface said would disappear.** So it is
+ * opt-in, and it only ever holds stories this account posted — an archive of
+ * other people's expiring stories is the exact opposite of what they were
+ * promised, and "it is private to you" does not repair that.
+ */
+class StoryArchiveTest {
+
+    private fun story(id: String, mine: Boolean, at: Long) = Vault.Story(
+        id = id, authorId = if (mine) 1L else 7L, mine = mine,
+        ref = Attachment.Ref(
+            kind = Attachment.STORY, id = "b$id", key = ByteArray(32),
+            digest = ByteArray(32), bytes = 1, mime = "image/jpeg",
+            width = 1, height = 1, duration = 0.0, expires = 1.0,
+        ),
+        caption = "c$id", postedAt = at,
+    )
+
+    @Test
+    fun `your own expired story is kept`() {
+        assertEquals(listOf("1"),
+            Vault.archive(emptyList(), listOf(story("1", true, 100))).map { it.id })
+    }
+
+    /** 🔴 The rule the whole feature turns on. */
+    @Test
+    fun `somebody elses expired story is never kept`() {
+        assertTrue(Vault.archive(emptyList(), listOf(story("2", false, 100))).isEmpty())
+    }
+
+    @Test
+    fun `a mixed batch keeps only your own`() {
+        val result = Vault.archive(emptyList(), listOf(
+            story("1", true, 100), story("2", false, 200), story("3", true, 300)))
+        assertEquals(setOf("1", "3"), result.map { it.id }.toSet())
+    }
+
+    /** ⚠️ The sweep runs on every load; without this, one story piles up. */
+    @Test
+    fun `archiving is idempotent`() {
+        val one = story("1", true, 100)
+        val first = Vault.archive(emptyList(), listOf(one))
+        assertEquals(1, Vault.archive(first, listOf(one)).size)
+    }
+
+    /** ⚠️ Newest first, so the screen needs no sort. */
+    @Test
+    fun `the archive is newest first`() {
+        val result = Vault.archive(emptyList(), listOf(
+            story("1", true, 100), story("3", true, 300), story("2", true, 200)))
+        assertEquals(listOf("3", "2", "1"), result.map { it.id })
+    }
+
+    private class MapStorage : Vault.Storage {
+        val records = LinkedHashMap<String, ByteArray>()
+        override fun read(name: String) = records[name]
+        override fun write(name: String, bytes: ByteArray) { records[name] = bytes }
+        override fun delete(name: String) { records.remove(name) }
+        override fun names() = records.keys.toList()
+    }
+
+    private fun key() = javax.crypto.KeyGenerator.getInstance("AES")
+        .apply { init(256) }.generateKey()
+
+    /** ⚠️ Kept in the vault, like everything else about somebody's stories. */
+    @Test
+    fun `the archive round-trips through the vault`() {
+        val vault = Vault(MapStorage(), key())
+        assertTrue(vault.storyArchive().isEmpty())
+        vault.saveStoryArchive(listOf(story("1", true, 100)))
+        assertEquals(listOf("1"), vault.storyArchive().map { it.id })
+    }
+
+    /**
+     * 🔴 The archive must NOT be swept by the expiry rule the live set uses —
+     * everything in it is expired by definition, so reusing `saveStories`
+     * would empty it on the next write.
+     */
+    @Test
+    fun `an expired story survives in the archive`() {
+        val vault = Vault(MapStorage(), key())
+        vault.saveStoryArchive(listOf(story("1", true, 100)))
+        assertEquals(1, vault.storyArchive().size)
+    }
+}