809 lines
45 KiB
Swift
809 lines
45 KiB
Swift
import AppKit
|
|
import ConjureKit
|
|
import Testing
|
|
@testable import Conjure
|
|
|
|
@Test @MainActor
|
|
func notesActionPillKeepsWindowInsetsWhenResized() throws {
|
|
_ = NSApplication.shared
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
|
let suite = "NotesLayout.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
defer {
|
|
try? FileManager.default.removeItem(at: directory)
|
|
defaults.removePersistentDomain(forName: suite)
|
|
}
|
|
let controller = NotesController(defaults: defaults, directory: directory)
|
|
let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390),
|
|
styleMask: [.borderless], backing: .buffered, defer: false)
|
|
window.contentViewController = controller
|
|
defer { _ = controller.close(); window.orderOut(nil) }
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
let pill = try #require(descendants(controller.view).first { $0 is ActionPill })
|
|
for size in [NSSize(width: 750, height: 390), NSSize(width: 570, height: 260)] {
|
|
window.setContentSize(size)
|
|
controller.view.layoutSubtreeIfNeeded()
|
|
let frame = pill.convert(pill.bounds, to: controller.view)
|
|
#expect(abs(frame.minY - controller.view.bounds.minY - 8) < 0.5)
|
|
#expect(abs(controller.view.bounds.maxX - frame.maxX - 8) < 0.5)
|
|
#expect(abs(frame.height - 36) < 0.5)
|
|
}
|
|
}
|
|
|
|
@Test @MainActor
|
|
func notesSwitchWithoutLeakingEditsUndoOrAttachmentsAndRestoreSelection() throws {
|
|
_ = NSApplication.shared
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
|
let suite = "NotesEditing.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
defer {
|
|
try? FileManager.default.removeItem(at: directory)
|
|
defaults.removePersistentDomain(forName: suite)
|
|
}
|
|
let controller = NotesController(defaults: defaults, directory: directory)
|
|
let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390), styleMask: [.borderless], backing: .buffered, defer: false)
|
|
window.contentViewController = controller
|
|
defer { _ = controller.close(); window.orderOut(nil) }
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
let views = descendants(controller.view)
|
|
let editor = try #require(views.compactMap { $0 as? NotesTextView }.first)
|
|
let browse = try #require(views.compactMap { $0 as? NSButton }.first { $0.title == "Browse Notes" })
|
|
func selectedID() throws -> UUID { try #require(defaults.string(forKey: "selectedNote").flatMap(UUID.init(uuidString:))) }
|
|
func picker(_ tool: NotesController) throws -> NSSearchField {
|
|
try #require(descendants(tool.view).compactMap { $0 as? NSSearchField }.first { $0.accessibilityLabel() == "Search notes" })
|
|
}
|
|
func filter(_ field: NSSearchField, _ query: String) {
|
|
field.stringValue = query
|
|
field.delegate?.controlTextDidChange?(Notification(name: NSControl.textDidChangeNotification, object: field))
|
|
field.window?.contentView?.layoutSubtreeIfNeeded()
|
|
}
|
|
let firstID = try selectedID()
|
|
// Empty notes have duplicate titles; UUID identity must survive the shared picker.
|
|
window.makeFirstResponder(editor)
|
|
let newNoteKey = try #require(NSEvent.keyEvent(with: .keyDown, location: .zero,
|
|
modifierFlags: .command, timestamp: 1, windowNumber: window.windowNumber, context: nil,
|
|
characters: "n", charactersIgnoringModifiers: "n", isARepeat: false, keyCode: 45))
|
|
#expect(window.performKeyEquivalent(with: newNoteKey))
|
|
let secondID = try selectedID()
|
|
#expect(secondID != firstID)
|
|
for expectedID in [firstID, secondID] {
|
|
browse.performClick(nil)
|
|
_ = try picker(controller)
|
|
let table = try #require(descendants(controller.view).compactMap { $0 as? NSTableView }.first)
|
|
#expect(table.numberOfRows == 2)
|
|
#expect(controller.handleControlKey(table.selectedRow == 0 ? "j" : "k"))
|
|
#expect(controller.handle(#selector(NSResponder.insertNewline(_:))))
|
|
#expect(try selectedID() == expectedID)
|
|
#expect(window.firstResponder === editor)
|
|
}
|
|
#expect(!controller.handleControlKey("j"))
|
|
#expect(!controller.handle(#selector(NSResponder.insertNewline(_:))))
|
|
editor.insertText(NoteDocument.importMarkdown(NSAttributedString(string: "# Second 🦊\n**bold** and `code`")),
|
|
replacementRange: editor.selectedRange())
|
|
let codeRange = (editor.string as NSString).range(of: "code")
|
|
let codeFont = try #require(editor.textStorage?.attribute(.font, at: codeRange.location, effectiveRange: nil) as? NSFont)
|
|
#expect(codeFont.isFixedPitch)
|
|
browse.performClick(nil)
|
|
filter(try picker(controller), "nttld")
|
|
#expect(controller.handle(#selector(NSResponder.insertNewline(_:))))
|
|
#expect(try selectedID() == firstID)
|
|
#expect(editor.string.isEmpty)
|
|
#expect(editor.undoManager?.canUndo != true)
|
|
editor.insertText("First note", replacementRange: editor.selectedRange())
|
|
let bitmap = try #require(NSBitmapImageRep(bitmapDataPlanes: nil, pixelsWide: 1, pixelsHigh: 1, bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false, colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0))
|
|
bitmap.setColor(.red, atX: 0, y: 0)
|
|
let imageURL = directory.appendingPathComponent("image.png")
|
|
let png = try #require(bitmap.representation(using: .png, properties: [:]))
|
|
try png.write(to: imageURL)
|
|
let pasteboard = NSPasteboard.withUniqueName()
|
|
defer { pasteboard.releaseGlobally() }
|
|
pasteboard.setData(png, forType: .png)
|
|
#expect(editor.readSelection(from: pasteboard))
|
|
pasteboard.clearContents()
|
|
pasteboard.writeObjects([imageURL as NSURL])
|
|
#expect(editor.readSelection(from: pasteboard))
|
|
#expect(controller.save())
|
|
let returnKey = try #require(NSEvent.keyEvent(with: .keyDown, location: .zero,
|
|
modifierFlags: [], timestamp: 2, windowNumber: window.windowNumber, context: nil,
|
|
characters: "\r", charactersIgnoringModifiers: "\r", isARepeat: false, keyCode: 36))
|
|
editor.keyDown(with: returnKey)
|
|
#expect(editor.string == "First note\u{fffc}\u{fffc}\n")
|
|
#expect(try selectedID() == firstID)
|
|
let restored = try NotesStore(directory: directory)
|
|
let first = try #require(restored.notes.first { $0.id == firstID })
|
|
#expect(first.contents.string == "First note\u{fffc}\u{fffc}\n")
|
|
#expect(first.contents.attribute(.attachment, at: 10, effectiveRange: nil) is NSTextAttachment)
|
|
#expect(first.contents.attribute(.attachment, at: 11, effectiveRange: nil) is NSTextAttachment)
|
|
let second = try #require(restored.notes.first { $0.id == secondID })
|
|
#expect(second.contents.string == "Second 🦊\nbold and code")
|
|
#expect(second.contents.attribute(NoteAttributes.headingLevel, at: 0, effectiveRange: nil) as? Int == 1)
|
|
#expect(second.contents.attribute(NoteAttributes.bold, at: "Second 🦊\n".utf16.count, effectiveRange: nil) as? Bool == true)
|
|
let reopened = NotesController(defaults: defaults, directory: directory)
|
|
let reopenedWindow = NSWindow(contentRect: window.frame, styleMask: [.borderless], backing: .buffered, defer: false)
|
|
reopenedWindow.contentViewController = reopened
|
|
defer { _ = reopened.close(); reopenedWindow.orderOut(nil) }
|
|
let reopenedViews = descendants(reopened.view)
|
|
let reopenedEditor = try #require(reopenedViews.compactMap { $0 as? NotesTextView }.first)
|
|
#expect(reopenedEditor.string == first.contents.string)
|
|
// Replacing formatted content must not leave stale paragraph or inline styles.
|
|
reopenedEditor.insertText("Plain text", replacementRange: NSRange(location: 0, length: reopenedEditor.string.utf16.count))
|
|
#expect(reopenedEditor.string == "Plain text")
|
|
let backup = directory.appendingPathExtension("backup")
|
|
defer { try? FileManager.default.removeItem(at: backup) }
|
|
try FileManager.default.moveItem(at: directory, to: backup)
|
|
try Data("Blocked storage".utf8).write(to: directory)
|
|
reopenedEditor.replaceDocument(NoteDocument.importMarkdown(NSAttributedString(string: "- [x] Unsaved")),
|
|
range: NSRange(location: 0, length: reopenedEditor.string.utf16.count))
|
|
var closed = false
|
|
reopened.closed = { closed = true }
|
|
reopened.goBack()
|
|
#expect(!closed)
|
|
#expect(!reopened.save())
|
|
reopened.browseNotes()
|
|
filter(try picker(reopened), "scnd")
|
|
#expect(reopened.handle(#selector(NSResponder.insertNewline(_:))))
|
|
#expect(reopenedEditor.string == "Unsaved")
|
|
#expect(reopenedEditor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
|
|
#expect(try selectedID() == firstID)
|
|
reopened.browseNotes()
|
|
#expect(!reopened.close())
|
|
#expect(!closed)
|
|
#expect(try picker(reopened).window === reopenedWindow)
|
|
try FileManager.default.removeItem(at: directory)
|
|
try FileManager.default.moveItem(at: backup, to: directory)
|
|
#expect(reopened.save())
|
|
let recovered = try #require(NotesStore(directory: directory).notes.first { $0.id == firstID })
|
|
#expect(recovered.contents.string == "Unsaved")
|
|
#expect(recovered.contents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
|
|
#expect(reopened.close())
|
|
#expect(closed)
|
|
#expect(!descendants(reopened.view).contains { ($0 as? NSSearchField)?.accessibilityLabel() == "Search notes" })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func notesLauncherRoutesShortcutsAndTearsDownPickersWithoutTakingEditorNavigation() throws {
|
|
_ = NSApplication.shared
|
|
let suite = "NotesShortcuts.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
|
|
defer {
|
|
defaults.removePersistentDomain(forName: suite)
|
|
try? FileManager.default.removeItem(at: directory)
|
|
}
|
|
let store = try NotesStore(directory: directory)
|
|
let atlas = try store.create()
|
|
let journal = try store.create()
|
|
try store.update(id: atlas, contents: NSAttributedString(string: "Project Atlas"))
|
|
try store.update(id: journal, contents: NSAttributedString(string: "Weekend journal"))
|
|
defaults.set(atlas.uuidString, forKey: "selectedNote")
|
|
let launcher = LauncherWindowController(
|
|
history: LaunchHistory(defaults: defaults, now: { Date(timeIntervalSinceReferenceDate: 12_000) }),
|
|
defaults: defaults, notesDirectory: directory)
|
|
let window = try #require(launcher.window)
|
|
defer { launcher.dismiss(restoringFocus: false) }
|
|
let content = try #require(window.contentView)
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
func search(_ label: String) throws -> NSSearchField {
|
|
try #require(descendants(content).compactMap { $0 as? NSSearchField }.first { $0.accessibilityLabel() == label })
|
|
}
|
|
func key(_ text: String, code: UInt16, flags: NSEvent.ModifierFlags = []) throws -> NSEvent {
|
|
let characters = flags == .control && text == "k" ? "\u{b}" : text
|
|
return try #require(NSEvent.keyEvent(with: .keyDown, location: .zero, modifierFlags: flags,
|
|
timestamp: 1, windowNumber: window.windowNumber, context: nil, characters: characters,
|
|
charactersIgnoringModifiers: text, isARepeat: false, keyCode: code))
|
|
}
|
|
func command(_ text: String, code: UInt16) throws {
|
|
#expect(window.performKeyEquivalent(with: try key(text, code: code, flags: .command)))
|
|
}
|
|
func filter(_ field: NSSearchField, _ text: String) {
|
|
field.stringValue = text
|
|
field.delegate?.controlTextDidChange?(Notification(name: NSControl.textDidChangeNotification, object: field))
|
|
content.layoutSubtreeIfNeeded()
|
|
}
|
|
let launcherSearch = try #require(descendants(content).compactMap { $0 as? NSSearchField }.first)
|
|
launcherSearch.stringValue = "notes"
|
|
launcher.controlTextDidChange(Notification(name: NSControl.textDidChangeNotification, object: launcherSearch))
|
|
#expect(launcher.control(launcherSearch, textView: NSTextView(), doCommandBy: #selector(NSResponder.insertNewline(_:))))
|
|
window.makeKeyAndOrderFront(nil)
|
|
let browse = try #require(descendants(content).compactMap { $0 as? NSButton }.first { $0.title == "Browse Notes" })
|
|
let tool = try #require(browse.target as? NotesController)
|
|
let editor = try #require(descendants(content).compactMap { $0 as? NSTextView }.first { $0.accessibilityLabel() == "Note editor" })
|
|
window.makeFirstResponder(editor)
|
|
try command("p", code: 35)
|
|
let picker = try search("Search notes")
|
|
let table = try #require(descendants(content).compactMap { $0 as? NSTableView }.first { $0.accessibilityLabel() == "Notes" })
|
|
#expect(window.firstResponder === picker.currentEditor())
|
|
#expect(tool.handle(#selector(NSResponder.moveUp(_:))))
|
|
window.sendEvent(try key("j", code: 38, flags: .control))
|
|
#expect(table.selectedRow == 1)
|
|
window.sendEvent(try key("k", code: 40, flags: .control))
|
|
#expect(table.selectedRow == 0)
|
|
filter(picker, "wkndjrnl")
|
|
#expect(table.numberOfRows == 1)
|
|
#expect(tool.handle(#selector(NSResponder.insertNewline(_:))))
|
|
#expect(defaults.string(forKey: "selectedNote") == journal.uuidString)
|
|
#expect(editor.string == "Weekend journal")
|
|
#expect(window.firstResponder === editor)
|
|
try command("p", code: 35)
|
|
_ = try search("Search notes")
|
|
try command("p", code: 35)
|
|
#expect(window.firstResponder === editor)
|
|
try command("k", code: 40)
|
|
filter(try search("Search notes actions"), "Browse Notes")
|
|
#expect(tool.handle(#selector(NSResponder.insertNewline(_:))))
|
|
_ = try search("Search notes")
|
|
window.sendEvent(try key("\u{1b}", code: 53))
|
|
#expect(window.isVisible && window.firstResponder === editor)
|
|
try command("k", code: 40)
|
|
filter(try search("Search notes actions"), "New Note")
|
|
#expect(tool.handle(#selector(NSResponder.insertNewline(_:))))
|
|
#expect(editor.string.isEmpty)
|
|
let actionCreatedID = defaults.string(forKey: "selectedNote")
|
|
try command("n", code: 45)
|
|
#expect(defaults.string(forKey: "selectedNote") != actionCreatedID)
|
|
let editorCreatedID = defaults.string(forKey: "selectedNote")
|
|
try command("p", code: 35)
|
|
_ = try search("Search notes")
|
|
try command("n", code: 45)
|
|
#expect(defaults.string(forKey: "selectedNote") != editorCreatedID)
|
|
#expect(window.firstResponder === editor)
|
|
#expect(!tool.handle(#selector(NSResponder.moveDown(_:))))
|
|
#expect(!tool.handleControlKey("k"))
|
|
editor.insertText("Navigation", replacementRange: editor.selectedRange())
|
|
editor.setSelectedRange(NSRange(location: 0, length: 0))
|
|
window.sendEvent(try key("k", code: 40, flags: .control))
|
|
#expect(editor.string.isEmpty)
|
|
editor.insertText("Editable", replacementRange: editor.selectedRange())
|
|
editor.keyDown(with: try key("\r", code: 36))
|
|
#expect(editor.string == "Editable\n")
|
|
try command("p", code: 35)
|
|
#expect(tool.close())
|
|
#expect(!descendants(content).compactMap { $0 as? NSSearchField }.contains { $0.accessibilityLabel() == "Search notes" })
|
|
#expect(launcherSearch.isHidden == false)
|
|
}
|
|
|
|
@Test(arguments: [false, true]) @MainActor
|
|
func notesNativeClosePreservesUnsavedEditsAndRestoresBorderlessLauncher(_ blockSaving: Bool) throws {
|
|
_ = NSApplication.shared
|
|
let suite = "NotesNativeClose.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
let root = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
|
|
let directory = root.appendingPathComponent("Notes")
|
|
let backup = root.appendingPathComponent("Backup")
|
|
defer {
|
|
defaults.removePersistentDomain(forName: suite)
|
|
try? FileManager.default.removeItem(at: root)
|
|
}
|
|
let launcher = LauncherWindowController(
|
|
history: LaunchHistory(defaults: defaults, now: { Date(timeIntervalSinceReferenceDate: 12_000) }),
|
|
defaults: defaults, notesDirectory: directory)
|
|
let window = try #require(launcher.window)
|
|
defer { launcher.dismiss(restoringFocus: false) }
|
|
let originalSize = window.frame.size
|
|
launcher.present(command: .notes)
|
|
let content = try #require(window.contentView)
|
|
content.layoutSubtreeIfNeeded()
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
let editor = try #require(descendants(content).compactMap { $0 as? NotesTextView }.first)
|
|
let close = try #require(window.standardWindowButton(.closeButton))
|
|
#expect(window.styleMask.contains(.titled))
|
|
#expect(!close.isHidden && close.isEnabled)
|
|
#expect(window.standardWindowButton(.miniaturizeButton)?.isHidden != false)
|
|
#expect(window.standardWindowButton(.zoomButton)?.isHidden != false)
|
|
if blockSaving {
|
|
try FileManager.default.moveItem(at: directory, to: backup)
|
|
try Data("Blocked storage".utf8).write(to: directory)
|
|
}
|
|
editor.insertText("Keep this note", replacementRange: editor.selectedRange())
|
|
close.performClick(nil)
|
|
if blockSaving {
|
|
#expect(window.isVisible)
|
|
#expect(editor.string == "Keep this note")
|
|
#expect(window.styleMask.contains(.titled))
|
|
try FileManager.default.removeItem(at: directory)
|
|
try FileManager.default.moveItem(at: backup, to: directory)
|
|
close.performClick(nil)
|
|
}
|
|
#expect(!window.isVisible)
|
|
#expect(window.styleMask == .borderless)
|
|
#expect(window.frame.size == originalSize)
|
|
#expect(try NotesStore(directory: directory).notes.first?.contents.string == "Keep this note")
|
|
launcher.present(command: .emoji)
|
|
#expect(window.styleMask == .borderless)
|
|
#expect(!descendants(content).contains { $0 is NotesTextView })
|
|
launcher.present(command: .notes)
|
|
#expect(window.standardWindowButton(.closeButton)?.isHidden == false)
|
|
#expect(window.standardWindowButton(.miniaturizeButton)?.isHidden != false)
|
|
#expect(window.standardWindowButton(.zoomButton)?.isHidden != false)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func notesRememberResizedDimensionsWithoutResizingOtherCommandsAndKeepTextMonospaced() throws {
|
|
_ = NSApplication.shared
|
|
let suite = "NotesWindowSize.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
|
|
defer {
|
|
defaults.removePersistentDomain(forName: suite)
|
|
try? FileManager.default.removeItem(at: directory)
|
|
}
|
|
func makeLauncher() -> LauncherWindowController {
|
|
LauncherWindowController(
|
|
history: LaunchHistory(defaults: defaults, now: { Date(timeIntervalSinceReferenceDate: 12_000) }),
|
|
defaults: defaults, notesDirectory: directory)
|
|
}
|
|
let launcher = makeLauncher()
|
|
let window = try #require(launcher.window)
|
|
defer { launcher.dismiss(restoringFocus: false) }
|
|
let launcherSize = window.frame.size
|
|
launcher.present(command: .notes)
|
|
#expect(window.styleMask.contains(.resizable))
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
let content = try #require(window.contentView)
|
|
let editor = try #require(descendants(content).compactMap { $0 as? NotesTextView }.first)
|
|
editor.insertText(NoteDocument.importMarkdown(NSAttributedString(string: "Plain\n# Heading\n**bold** and *italic* and `code`")),
|
|
replacementRange: editor.selectedRange())
|
|
let storage = try #require(editor.textStorage)
|
|
storage.enumerateAttribute(.font, in: NSRange(location: 0, length: storage.length)) { value, _, _ in
|
|
#expect((value as? NSFont)?.isFixedPitch == true)
|
|
}
|
|
#expect((editor.typingAttributes[.font] as? NSFont)?.isFixedPitch == true)
|
|
let expanded = NSSize(width: 840, height: 620)
|
|
var frame = window.frame
|
|
frame.size = expanded
|
|
window.setFrame(frame, display: true)
|
|
window.contentView?.layoutSubtreeIfNeeded()
|
|
#expect(editor.enclosingScrollView?.frame.width == expanded.width)
|
|
#expect(editor.visibleRect.height > 400)
|
|
launcher.present(command: .emoji)
|
|
#expect(window.frame.size == launcherSize)
|
|
#expect(!window.styleMask.contains(.resizable))
|
|
launcher.present(command: .notes)
|
|
#expect(window.frame.size == expanded)
|
|
let compact = NSSize(width: 620, height: 330)
|
|
frame = window.frame
|
|
frame.size = compact
|
|
window.setFrame(frame, display: true)
|
|
launcher.dismiss(restoringFocus: false)
|
|
|
|
// A fresh controller reads persisted dimensions, not an in-memory frame.
|
|
let reopened = makeLauncher()
|
|
defer { reopened.dismiss(restoringFocus: false) }
|
|
reopened.present(command: .notes)
|
|
#expect(reopened.window?.frame.size == compact)
|
|
reopened.present(command: .translate)
|
|
#expect(reopened.window?.frame.size == launcherSize)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func structuredListsContinueSplitOutdentAndUndoWithoutSourceMarkers() throws {
|
|
_ = NSApplication.shared
|
|
let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
|
|
editor.allowsUndo = true
|
|
let window = NSWindow(contentRect: editor.frame, styleMask: .borderless, backing: .buffered, defer: false)
|
|
window.contentView = editor
|
|
window.makeFirstResponder(editor)
|
|
defer { window.orderOut(nil) }
|
|
func reset(_ source: String) {
|
|
editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
|
|
editor.setSelectedRange(NSRange(location: editor.string.utf16.count, length: 0))
|
|
editor.undoManager?.removeAllActions()
|
|
}
|
|
for (source, block, number) in [
|
|
("- fox 🦊", "bullet", 0), ("9. ninth", "ordered", 10),
|
|
("- [x] finished", "task", 0),
|
|
] {
|
|
reset(source)
|
|
let before = editor.string
|
|
editor.insertNewline(nil)
|
|
editor.insertText("next", replacementRange: editor.selectedRange())
|
|
#expect(editor.string == before + "\nnext")
|
|
let index = before.utf16.count + 1
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: index, effectiveRange: nil) as? String == block)
|
|
if number > 0 {
|
|
#expect(editor.documentContents.attribute(NoteAttributes.number, at: index, effectiveRange: nil) as? Int == number)
|
|
}
|
|
if block == "task" {
|
|
#expect(editor.documentContents.attribute(NoteAttributes.checked, at: index, effectiveRange: nil) as? Bool == false)
|
|
}
|
|
}
|
|
reset("- ab🦊cd")
|
|
editor.setSelectedRange((editor.string as NSString).range(of: "🦊"))
|
|
editor.insertNewline(nil)
|
|
#expect(editor.string == "ab\ncd")
|
|
#expect(editor.selectedRange() == NSRange(location: 3, length: 0))
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 3, effectiveRange: nil) as? String == "bullet")
|
|
editor.undoManager?.undo()
|
|
#expect(editor.string == "ab🦊cd")
|
|
#expect(editor.selectedRange() == NSRange(location: 2, length: 2))
|
|
editor.undoManager?.redo()
|
|
#expect(editor.string == "ab\ncd")
|
|
|
|
reset("- parent\n - child\n - leaf")
|
|
editor.insertNewline(nil)
|
|
editor.insertText("temporary", replacementRange: editor.selectedRange())
|
|
let last = (editor.string as NSString).range(of: "temporary")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.depth, at: last.location, effectiveRange: nil) as? Int == 2)
|
|
editor.insertText("", replacementRange: last)
|
|
editor.insertNewline(nil)
|
|
editor.insertText("sibling", replacementRange: editor.selectedRange())
|
|
let sibling = (editor.string as NSString).range(of: "sibling")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.depth, at: sibling.location, effectiveRange: nil) as? Int == 1)
|
|
editor.insertText("", replacementRange: sibling)
|
|
editor.insertNewline(nil)
|
|
editor.insertNewline(nil)
|
|
editor.insertText("body", replacementRange: editor.selectedRange())
|
|
let body = (editor.string as NSString).range(of: "body")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: body.location, effectiveRange: nil) == nil)
|
|
|
|
reset("```md\n- literal\n```")
|
|
editor.insertNewline(nil)
|
|
editor.insertText("- still literal", replacementRange: editor.selectedRange())
|
|
#expect(editor.string == "- literal\n- still literal")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: editor.string.utf16.count - 1, effectiveRange: nil) as? String == "code")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func typedParagraphShortcutsConsumeMarkersWithoutCreatingAttachments() throws {
|
|
_ = NSApplication.shared
|
|
let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
|
|
for (marker, block) in [("- ", "bullet"), ("* ", "bullet"), ("+ ", "bullet"),
|
|
("12) ", "ordered"), ("- [ ] ", "task"), ("- [] ", "task"),
|
|
("- [x] ", "task"), ("> ", "quote")] {
|
|
editor.setDocumentContents(NSAttributedString(string: ""))
|
|
editor.setSelectedRange(NSRange(location: 0, length: 0))
|
|
for character in marker + "🦊 body" {
|
|
editor.insertText(String(character), replacementRange: editor.selectedRange())
|
|
}
|
|
#expect(editor.string == "🦊 body")
|
|
#expect(editor.selectedRange() == NSRange(location: "🦊 body".utf16.count, length: 0))
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == block)
|
|
#expect(editor.documentContents.attribute(.attachment, at: 0, effectiveRange: nil) == nil)
|
|
if block == "task" {
|
|
#expect(editor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == marker.contains("[x]"))
|
|
}
|
|
if block == "ordered" {
|
|
#expect(editor.documentContents.attribute(NoteAttributes.number, at: 0, effectiveRange: nil) as? Int == 12)
|
|
}
|
|
}
|
|
for literal in ["-word", "1.word", "prose - item", "unmatched *text", "\\*escaped*"] {
|
|
editor.setDocumentContents(NSAttributedString(string: ""))
|
|
editor.setSelectedRange(NSRange(location: 0, length: 0))
|
|
for character in literal {
|
|
editor.insertText(String(character), replacementRange: editor.selectedRange())
|
|
}
|
|
#expect(editor.string == literal)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
|
|
}
|
|
}
|
|
|
|
@Test @MainActor
|
|
func listIndentationPreservesActualUnicodeSelectionsAndUndo() throws {
|
|
_ = NSApplication.shared
|
|
let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
|
|
editor.allowsUndo = true
|
|
let window = NSWindow(contentRect: editor.frame, styleMask: .borderless, backing: .buffered, defer: false)
|
|
window.contentView = editor
|
|
window.makeFirstResponder(editor)
|
|
defer { window.orderOut(nil) }
|
|
for source in ["- parent\n- 🦊 café", "1. parent\n2. 🦊 café\n3. tail", "- [ ] parent\n- [x] 🦊 café"] {
|
|
editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
|
|
let selection = (editor.string as NSString).range(of: "🦊 café")
|
|
editor.setSelectedRange(selection)
|
|
editor.undoManager?.removeAllActions()
|
|
let before = editor.string
|
|
editor.insertTab(nil)
|
|
#expect(editor.string == before)
|
|
#expect(editor.selectedRange() == selection)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int == 1)
|
|
if source.hasPrefix("1.") {
|
|
let tail = (editor.string as NSString).range(of: "tail").location
|
|
#expect(editor.documentContents.attribute(NoteAttributes.number, at: selection.location, effectiveRange: nil) as? Int == 1)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.number, at: tail, effectiveRange: nil) as? Int == 2)
|
|
}
|
|
editor.undoManager?.undo()
|
|
#expect(editor.selectedRange() == selection)
|
|
#expect((editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int ?? 0) == 0)
|
|
editor.undoManager?.redo()
|
|
#expect(editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int == 1)
|
|
editor.insertBacktab(nil)
|
|
#expect(editor.string == before)
|
|
#expect(editor.selectedRange() == selection)
|
|
#expect((editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int ?? 0) == 0)
|
|
if source.hasPrefix("1.") {
|
|
let tail = (editor.string as NSString).range(of: "tail").location
|
|
#expect(editor.documentContents.attribute(NoteAttributes.number, at: selection.location, effectiveRange: nil) as? Int == 2)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.number, at: tail, effectiveRange: nil) as? Int == 3)
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test @MainActor
|
|
func taskCheckboxesToggleSemanticStateWithUndoAndPersistence() throws {
|
|
_ = NSApplication.shared
|
|
let suite = "NotesTasks.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
|
|
defer {
|
|
defaults.removePersistentDomain(forName: suite)
|
|
try? FileManager.default.removeItem(at: directory)
|
|
}
|
|
let store = try NotesStore(directory: directory)
|
|
let id = try store.create()
|
|
try store.update(id: id, contents: NoteDocument.importMarkdown(NSAttributedString(string:
|
|
"- [ ] buy 🦊\n - [x] nested\n```md\n- [ ] literal\n```\nprose - [ ] not a task")))
|
|
defaults.set(id.uuidString, forKey: "selectedNote")
|
|
let controller = NotesController(defaults: defaults, directory: directory)
|
|
let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390),
|
|
styleMask: .borderless, backing: .buffered, defer: false)
|
|
window.contentViewController = controller
|
|
defer { _ = controller.close(); window.orderOut(nil) }
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
let editor = try #require(descendants(controller.view).compactMap { $0 as? NotesTextView }.first)
|
|
window.makeFirstResponder(editor)
|
|
let before = editor.string
|
|
#expect(before == "buy 🦊\nnested\n- [ ] literal\nprose - [ ] not a task")
|
|
let boxes = editor.subviews.compactMap { $0 as? NSButton }
|
|
#expect(boxes.map(\.state) == [.off, .on])
|
|
let first = try #require(boxes.first)
|
|
#expect(first.cell?.accessibilityRole() == .checkBox)
|
|
#expect(first.accessibilityLabel() == "buy 🦊")
|
|
let selection = NSRange(location: 2, length: 2)
|
|
editor.setSelectedRange(selection)
|
|
editor.undoManager?.removeAllActions()
|
|
first.performClick(nil)
|
|
#expect(editor.string == before)
|
|
#expect(editor.selectedRange() == selection)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
|
|
#expect(controller.save())
|
|
let saved = try #require(NotesStore(directory: directory).notes.first { $0.id == id })
|
|
#expect(saved.contents.string == before)
|
|
#expect(saved.contents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
|
|
editor.undoManager?.undo()
|
|
#expect(editor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == false)
|
|
#expect(editor.subviews.compactMap { $0 as? NSButton }.first?.state == .off)
|
|
editor.undoManager?.redo()
|
|
#expect(editor.subviews.compactMap { $0 as? NSButton }.first?.state == .on)
|
|
#expect(controller.save())
|
|
let reopened = NotesController(defaults: defaults, directory: directory)
|
|
defer { _ = reopened.close() }
|
|
let restored = try #require(descendants(reopened.view).compactMap { $0 as? NotesTextView }.first)
|
|
#expect(restored.string == before)
|
|
#expect(restored.subviews.compactMap { $0 as? NSButton }.map(\.state) == [.on, .on])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func listBodiesUseActualTextOffsetsForTypingPasteReplacementAndDeletion() throws {
|
|
_ = NSApplication.shared
|
|
let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
|
|
editor.allowsUndo = true
|
|
let window = NSWindow(contentRect: editor.frame, styleMask: .borderless, backing: .buffered, defer: false)
|
|
window.contentView = editor
|
|
window.makeFirstResponder(editor)
|
|
defer { window.orderOut(nil) }
|
|
let board = NSPasteboard.withUniqueName()
|
|
defer { board.releaseGlobally() }
|
|
board.setString("**literal paste**", forType: .string)
|
|
for source in ["- ab🦊cd", "12. ab🦊cd", "- [x] ab🦊cd"] {
|
|
editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
|
|
#expect(editor.string == "ab🦊cd")
|
|
editor.setSelectedRange(NSRange(location: 0, length: 0))
|
|
editor.moveRight(nil)
|
|
#expect(editor.selectedRange().location == 1)
|
|
editor.setSelectedRange((editor.string as NSString).range(of: "🦊"))
|
|
editor.undoManager?.removeAllActions()
|
|
editor.insertText("X", replacementRange: editor.selectedRange())
|
|
#expect(editor.string == "abXcd")
|
|
editor.undoManager?.undo()
|
|
#expect(editor.string == "ab🦊cd")
|
|
#expect(editor.selectedRange() == NSRange(location: 2, length: 2))
|
|
editor.undoManager?.redo()
|
|
#expect(editor.string == "abXcd")
|
|
editor.setSelectedRange(NSRange(location: 0, length: 0))
|
|
#expect(editor.readSelection(from: board))
|
|
#expect(editor.string == "**literal paste**abXcd")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.bold, at: 2, effectiveRange: nil) as? Bool != true)
|
|
editor.insertText(" ", replacementRange: NSRange(location: 0, length: 0))
|
|
editor.setSelectedRange(NSRange(location: 0, length: 0))
|
|
editor.moveRight(nil)
|
|
#expect(editor.selectedRange().location == 1)
|
|
editor.moveRight(nil)
|
|
#expect(editor.selectedRange().location == 2)
|
|
}
|
|
editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: "prose\n- item")))
|
|
editor.setSelectedRange(NSRange(location: "prose\n".utf16.count, length: 0))
|
|
editor.undoManager?.removeAllActions()
|
|
editor.deleteBackward(nil)
|
|
#expect(editor.string == "proseitem")
|
|
editor.undoManager?.undo()
|
|
#expect(editor.string == "prose\nitem")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 6, effectiveRange: nil) as? String == "bullet")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func mixedListBodiesAndWrappedLinesShareColumnsAtEachDepth() throws {
|
|
_ = NSApplication.shared
|
|
let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 400, height: 800))
|
|
let continuation = String(repeating: " wrapped words", count: 15)
|
|
let rows = [("- ", "bullet"), ("1. ", "ordered"), ("123456789. ", "wide"),
|
|
("- [ ] ", "task"), (" - ", "nested"), (" - [x] ", "nestedTask")]
|
|
let source = rows.map { $0.0 + $0.1 + continuation }.joined(separator: "\n")
|
|
editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
|
|
let layout = try #require(editor.layoutManager)
|
|
let container = try #require(editor.textContainer)
|
|
layout.ensureLayout(for: container)
|
|
func position(_ glyph: Int) -> NSPoint {
|
|
let fragment = layout.lineFragmentRect(forGlyphAt: glyph, effectiveRange: nil)
|
|
let location = layout.location(forGlyphAt: glyph)
|
|
return NSPoint(x: fragment.minX + location.x, y: fragment.minY + location.y)
|
|
}
|
|
var columns: [CGFloat] = []
|
|
for row in rows {
|
|
let body = (editor.string as NSString).range(of: row.1 + continuation)
|
|
let glyphs = layout.glyphRange(forCharacterRange: body, actualCharacterRange: nil)
|
|
let column = position(glyphs.location).x
|
|
columns.append(column)
|
|
var lines = 0
|
|
layout.enumerateLineFragments(forGlyphRange: glyphs) { _, _, _, lineGlyphs, _ in
|
|
#expect(abs(position(lineGlyphs.location).x - column) < 0.5)
|
|
lines += 1
|
|
}
|
|
#expect(lines > 1)
|
|
}
|
|
for column in columns.prefix(4) { #expect(abs(column - columns[0]) < 0.5) }
|
|
#expect(abs(columns[4] - columns[5]) < 0.5)
|
|
#expect(columns[4] > columns[0])
|
|
#expect(!editor.string.contains("\u{fffc}"))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func notesToolbarFormattingPreservesAttachmentsSelectionAndUndo() throws {
|
|
_ = NSApplication.shared
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
|
let suite = "NotesFormatting.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
defer {
|
|
try? FileManager.default.removeItem(at: directory)
|
|
defaults.removePersistentDomain(forName: suite)
|
|
}
|
|
let controller = NotesController(defaults: defaults, directory: directory)
|
|
let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 570, height: 404),
|
|
styleMask: .borderless, backing: .buffered, defer: false)
|
|
window.contentViewController = controller
|
|
defer { _ = controller.close(); window.orderOut(nil) }
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
let views = descendants(controller.view)
|
|
let editor = try #require(views.compactMap { $0 as? NotesTextView }.first)
|
|
func click(_ label: String) throws {
|
|
try #require(views.compactMap { $0 as? NSButton }.first { $0.accessibilityLabel() == label }).performClick(nil)
|
|
}
|
|
window.makeFirstResponder(editor)
|
|
editor.insertText("🦊 first\nsecond\nuntouched", replacementRange: editor.selectedRange())
|
|
let selection = NSRange(location: 0, length: "🦊 first\nsecond\n".utf16.count)
|
|
editor.setSelectedRange(selection)
|
|
for (label, block) in [("Bullet list", "bullet"), ("Ordered list", "ordered"), ("Checklist", "task")] {
|
|
try click(label)
|
|
#expect(editor.string == "🦊 first\nsecond\nuntouched")
|
|
#expect(editor.selectedRange() == selection)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == block)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: "🦊 first\n".utf16.count, effectiveRange: nil) as? String == block)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: "🦊 first\nsecond\n".utf16.count, effectiveRange: nil) == nil)
|
|
}
|
|
try click("Checklist")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
|
|
try click("Bold")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.bold, at: 0, effectiveRange: nil) as? Bool == true)
|
|
try click("Bold")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.bold, at: 0, effectiveRange: nil) as? Bool != true)
|
|
#expect(editor.selectedRange() == selection)
|
|
editor.setSelectedRange(NSRange(location: 3, length: 0))
|
|
try click("Code block")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == "code")
|
|
try click("Code block")
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
|
|
let bitmap = try #require(NSBitmapImageRep(bitmapDataPlanes: nil, pixelsWide: 1, pixelsHigh: 1,
|
|
bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false,
|
|
colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0))
|
|
bitmap.setColor(.red, atX: 0, y: 0)
|
|
let png = try #require(bitmap.representation(using: .png, properties: [:]))
|
|
let file = FileWrapper(regularFileWithContents: png)
|
|
file.preferredFilename = "pixel.png"
|
|
editor.insertText(NSAttributedString(attachment: NSTextAttachment(fileWrapper: file)),
|
|
replacementRange: NSRange(location: editor.string.utf16.count, length: 0))
|
|
let before = editor.string
|
|
editor.setSelectedRange(NSRange(location: 0, length: editor.string.utf16.count))
|
|
editor.undoManager?.removeAllActions()
|
|
try click("Quote")
|
|
#expect(editor.string == before)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == "quote")
|
|
editor.undoManager?.undo()
|
|
#expect(editor.string == before)
|
|
#expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
|
|
#expect(controller.save())
|
|
let saved = try #require(NotesStore(directory: directory).notes.first)
|
|
#expect(saved.contents.string == before)
|
|
let attachment = try #require(saved.contents.attribute(.attachment, at: saved.contents.length - 1, effectiveRange: nil) as? NSTextAttachment)
|
|
#expect(attachment.fileWrapper?.regularFileContents == png)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func notesDeletionRequiresConfirmationPreservesFailuresAndReplacesTheLastNote() async throws {
|
|
_ = NSApplication.shared
|
|
let suite = "NotesDeletion.\(UUID().uuidString)"
|
|
let defaults = try #require(UserDefaults(suiteName: suite))
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
|
|
let backup = directory.appendingPathExtension("backup")
|
|
defer {
|
|
defaults.removePersistentDomain(forName: suite)
|
|
try? FileManager.default.removeItem(at: directory)
|
|
try? FileManager.default.removeItem(at: backup)
|
|
}
|
|
let store = try NotesStore(directory: directory)
|
|
let first = try store.create()
|
|
let second = try store.create()
|
|
try store.update(id: first, contents: NSAttributedString(string: "Delete this note"))
|
|
try store.update(id: second, contents: NSAttributedString(string: "Keep this note"))
|
|
defaults.set(first.uuidString, forKey: "selectedNote")
|
|
let controller = NotesController(defaults: defaults, directory: directory)
|
|
let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 570, height: 404),
|
|
styleMask: [.titled], backing: .buffered, defer: false)
|
|
window.contentViewController = controller
|
|
defer { _ = controller.close(); window.orderOut(nil) }
|
|
window.orderFront(nil)
|
|
func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
|
|
let editor = try #require(descendants(controller.view).compactMap { $0 as? NotesTextView }.first)
|
|
func delete(confirm: Bool) async throws {
|
|
controller.showActions()
|
|
let search = try #require(descendants(controller.view).compactMap { $0 as? NSSearchField }.first)
|
|
search.stringValue = "delete"
|
|
search.delegate?.controlTextDidChange?(Notification(name: NSControl.textDidChangeNotification, object: search))
|
|
#expect(controller.handle(#selector(NSResponder.insertNewline(_:))))
|
|
let sheet = try #require(window.attachedSheet)
|
|
let content = try #require(sheet.contentView)
|
|
let buttons = descendants(content).compactMap { $0 as? NSButton }
|
|
let delete = try #require(buttons.first { $0.title == "Delete Note" })
|
|
#expect(sheet.firstResponder === delete)
|
|
let button = try #require(buttons.first { $0.title == (confirm ? "Delete Note" : "Cancel") })
|
|
button.performClick(nil)
|
|
// Scheduling deadline only; deletion does not depend on wall-clock time.
|
|
for _ in 0..<1_000 {
|
|
if window.attachedSheet == nil, window.firstResponder === editor { return }
|
|
try await Task.sleep(for: .milliseconds(1))
|
|
}
|
|
try #require(window.attachedSheet == nil && window.firstResponder === editor)
|
|
}
|
|
try await delete(confirm: false)
|
|
#expect(defaults.string(forKey: "selectedNote") == first.uuidString)
|
|
#expect(editor.string == "Delete this note")
|
|
#expect(Set(try NotesStore(directory: directory).notes.map(\.id)) == Set([first, second]))
|
|
|
|
// A failed save must not let confirmation discard an unsaved buffer.
|
|
try FileManager.default.moveItem(at: directory, to: backup)
|
|
try Data("Blocked storage".utf8).write(to: directory)
|
|
editor.insertText("Unsaved changes", replacementRange: NSRange(location: 0, length: editor.string.utf16.count))
|
|
try await delete(confirm: true)
|
|
#expect(defaults.string(forKey: "selectedNote") == first.uuidString)
|
|
#expect(editor.string == "Unsaved changes")
|
|
#expect(!controller.save())
|
|
try FileManager.default.removeItem(at: directory)
|
|
try FileManager.default.moveItem(at: backup, to: directory)
|
|
#expect(try NotesStore(directory: directory).notes.first { $0.id == first }?.contents.string == "Delete this note")
|
|
|
|
try await delete(confirm: true)
|
|
#expect(try NotesStore(directory: directory).notes.map(\.id) == [second])
|
|
#expect(defaults.string(forKey: "selectedNote") == second.uuidString)
|
|
#expect(editor.string == "Keep this note")
|
|
#expect(editor.undoManager?.canUndo != true)
|
|
try await delete(confirm: true)
|
|
let replacement = try #require(NotesStore(directory: directory).notes.first)
|
|
#expect(replacement.id != first && replacement.id != second)
|
|
#expect(replacement.contents.string.isEmpty)
|
|
#expect(defaults.string(forKey: "selectedNote") == replacement.id.uuidString)
|
|
#expect(editor.string.isEmpty)
|
|
#expect(editor.isEditable)
|
|
#expect(editor.undoManager?.canUndo != true)
|
|
let reopened = NotesController(defaults: defaults, directory: directory)
|
|
#expect(descendants(reopened.view).compactMap { $0 as? NotesTextView }.first?.string == "")
|
|
#expect(defaults.string(forKey: "selectedNote") == replacement.id.uuidString)
|
|
}
|