SidecarPropertyRegistrationSmokeTest.kt

    private fun verifyEverySidecarPropertyCanBeWritten() {
        val persistent = Box.ioPersistentProperties.map { it.toRegex() }
        val orphans = Box.ioSeparateProperties.keys.filterNot { property ->
            persistent.any { property.matches(it) }
        }
        require(orphans.isEmpty()) {
            "these properties name a sidecar file but are not in Box.ioPersistentProperties, so a " +
                "save drops them before the sidecar is ever written: $orphans — either add a " +
                "matching ioPersistentProperties pattern, or remove the ioSeparateProperties entry"
        }
        require(Box.ioSeparateProperties.isNotEmpty() && persistent.isNotEmpty()) {
            "the registries are empty, so this test is asserting nothing"
        }
        println(
            "every sidecar property is persistent ✓ " +
                "(${Box.ioSeparateProperties.size} sidecar keys vs ${persistent.size} persistent patterns)"
        )
    }

    private fun verifyRemoteJsIsNotRegisteredAnywhere() {
        require(!Box.ioSeparateProperties.containsKey(DEAD_PROPERTY)) {
            "$DEAD_PROPERTY is a box *name*, not a property, and must not claim a sidecar extension"
        }
        require(Box.ioPersistentProperties.none { it.toRegex().matches(DEAD_PROPERTY) }) {
            "$DEAD_PROPERTY must not be persistent; nothing reads or writes such a property"
        }
        require(Box.uiResyncProperties.none { it.matches(DEAD_PROPERTY) }) {
            "$DEAD_PROPERTY must not resync; there is no editor pane behind it"
        }
        // `customization` is the live Javascript property `remote_js` was mistaken for, and it is
        // registered in all three. Asserting it here keeps the test honest: the three checks above
        // pass trivially for any misspelling, so pin that the real property is fully wired.
        require(Box.ioSeparateProperties["customization"] == "js") {
            "customization must still save as a .js sidecar, got ${Box.ioSeparateProperties["customization"]}"
        }
        require(Box.ioPersistentProperties.any { it.toRegex().matches("customization") }) {
            "customization must be persistent"
        }
        require(Box.uiResyncProperties.any { it.matches("customization") }) {
            "customization must resync"
        }
        println("remote_js is registered nowhere; customization is registered everywhere ✓")
    }

    private fun verifySerializationKeepsCustomizationAndDropsAnUnregisteredProperty() {
        val workspace = Files.createTempDirectory("afield-sidecar-registration").toFile()
        val document = File(workspace, "doc").also { it.mkdirs() }
        File(document, SavingContext.METADATA_EDN).writeText("{:version 2 :boxes []}\n")

        val root = Box("root")
        val session = SessionInformation(
            filename = document.absolutePath,
            documentName = document.name,
            boxes = ConcurrentHashMap(),
            root = root,
            ephemeral = true
        )
        root.inside = session
        session.boxes[root.id] = root
        thisSessionInfo.set(session)

        try {
            val box = Box("registrationbox")
            box.inside = session
            session.boxes[box.id] = box
            box.setPropertyRaw("name", "registration box", doResync = false)
            box.setPropertyRaw("customization", "// a live javascript property", doResync = false)
            box.setPropertyRaw(DEAD_PROPERTY, "// never persisted", doResync = false)
            require(box.getPropertyRaw(DEAD_PROPERTY) != null) {
                "the test needs $DEAD_PROPERTY actually set on the box for the drop to mean anything"
            }

            // The sidecar-writing path: `toTransfer` writes each sidecar as it goes.
            val transfer = SavingContext().toTransfer(setOf(box), document.absolutePath)
                .single { it.id == box.id }
            require("customization" in transfer.properties) {
                "customization should have been serialized, got ${transfer.properties.keys}"
            }
            require(DEAD_PROPERTY !in transfer.properties) {
                "$DEAD_PROPERTY survived the ioPersistentProperties filter: ${transfer.properties.keys}"
            }

            val written = document.listFiles()?.map { it.name }?.sorted() ?: emptyList()
            require("registrationbox_customization_.js" in written) {
                "expected a customization sidecar on disk, got $written"
            }
            require(written.none { it.endsWith("_${DEAD_PROPERTY}_.js") }) {
                "a $DEAD_PROPERTY sidecar was written; it is not a property: $written"
            }

            // The inline path, which is what `metadata.edn` and `document.md` are built from.
            val edn = SavingContext().exportEdnPackage(setOf(box), document.absolutePath)
            require("\"customization\"" in edn) { "customization missing from the exported EDN" }
            require("\"$DEAD_PROPERTY\"" !in edn) {
                "$DEAD_PROPERTY leaked into the exported EDN as an inline property"
            }

            println("serialization writes customization, drops $DEAD_PROPERTY \u2713")
        } finally {
            thisSessionInfo.remove()
            workspace.deleteRecursively()
        }
    }
}