From 48419065b1ba6922493d05c9a466c7040805aa92 Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Fri, 1 May 2026 21:59:17 +0200 Subject: [PATCH 1/9] Adds unit tests (#124) --- .../CloudMigrationJotBusinessModelTests.swift | 81 ++++ .../CloudMigrationRepositoryTests.swift | 167 ++++++++ .../DefaultsContinuationStorageTests.swift | 76 ++++ Tests/Defaults/DefaultsKeyTests.swift | 46 +++ Tests/Defaults/DefaultsServiceTests.swift | 99 +++++ .../EditJotPage/EditJotRepositoryTests.swift | 151 ++++++++ .../FeatureRowCellViewModelTests.swift | 19 + Tests/FileService/UbiquitousInfoTests.swift | 42 ++ Tests/Helpers/URL+staticString.swift | 11 + Tests/Jot/JotFileServiceTests.swift | 360 ++++++++++++++++++ Tests/Jot/JotFileTests.swift | 49 +++ .../JotConflictBusinessModelTests.swift | 77 ++++ ...achedJotFilePreviewImageServiceTests.swift | 114 ++++++ Tests/JotsPage/CreateJotRepositoryTests.swift | 124 ++++++ Tests/JotsPage/DeleteJotRepositoryTests.swift | 31 ++ .../EmptyStateCellViewModelTests.swift | 29 ++ Tests/JotsPage/JotBusinessModelTests.swift | 75 ++++ .../JotMenuConfigurationFactoryTests.swift | 133 +++++++ Tests/JotsPage/JotsRepositoryTests.swift | 194 ++++++++++ Tests/JotsPage/RenameJotRepositoryTests.swift | 40 ++ Tests/Mocks/ApplicationServiceMock.swift | 25 ++ Tests/Mocks/BundleServiceMock.swift | 12 + Tests/Mocks/DefaultsServiceMock.swift | 48 +++ Tests/Mocks/DeviceServiceMock.swift | 13 + Tests/Mocks/FileServiceMock.swift | 75 ++++ Tests/Mocks/JotFileConflictServiceMock.swift | 38 ++ .../JotFilePreviewImageServiceMock.swift | 33 ++ Tests/Mocks/JotFileServiceMock.swift | 66 ++++ Tests/Navigation/EditJotURLTests.swift | 76 ++++ .../EnableICloudSupportURLTests.swift | 42 ++ Tests/Navigation/JotsPageURLTests.swift | 25 ++ Tests/Navigation/JottreGithubURLTests.swift | 24 ++ Tests/Navigation/RevealFileURLTests.swift | 41 ++ .../PageCellSizingStrategyTests.swift | 65 ++++ .../PageHeaderCellViewModelTests.swift | 19 + .../SettingsRepositoryTests.swift | 115 ++++++ Tests/Utilities/Array+safeIndexTests.swift | 39 ++ .../AsyncSequenceDebounceTests.swift | 51 +++ ...ncSequenceToAsyncThrowingStreamTests.swift | 64 ++++ project.yml | 59 +++ 40 files changed, 2848 insertions(+) create mode 100644 Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift create mode 100644 Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift create mode 100644 Tests/Defaults/DefaultsContinuationStorageTests.swift create mode 100644 Tests/Defaults/DefaultsKeyTests.swift create mode 100644 Tests/Defaults/DefaultsServiceTests.swift create mode 100644 Tests/EditJotPage/EditJotRepositoryTests.swift create mode 100644 Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift create mode 100644 Tests/FileService/UbiquitousInfoTests.swift create mode 100644 Tests/Helpers/URL+staticString.swift create mode 100644 Tests/Jot/JotFileServiceTests.swift create mode 100644 Tests/Jot/JotFileTests.swift create mode 100644 Tests/JotConflictPage/JotConflictBusinessModelTests.swift create mode 100644 Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift create mode 100644 Tests/JotsPage/CreateJotRepositoryTests.swift create mode 100644 Tests/JotsPage/DeleteJotRepositoryTests.swift create mode 100644 Tests/JotsPage/EmptyStateCellViewModelTests.swift create mode 100644 Tests/JotsPage/JotBusinessModelTests.swift create mode 100644 Tests/JotsPage/JotMenuConfigurationFactoryTests.swift create mode 100644 Tests/JotsPage/JotsRepositoryTests.swift create mode 100644 Tests/JotsPage/RenameJotRepositoryTests.swift create mode 100644 Tests/Mocks/ApplicationServiceMock.swift create mode 100644 Tests/Mocks/BundleServiceMock.swift create mode 100644 Tests/Mocks/DefaultsServiceMock.swift create mode 100644 Tests/Mocks/DeviceServiceMock.swift create mode 100644 Tests/Mocks/FileServiceMock.swift create mode 100644 Tests/Mocks/JotFileConflictServiceMock.swift create mode 100644 Tests/Mocks/JotFilePreviewImageServiceMock.swift create mode 100644 Tests/Mocks/JotFileServiceMock.swift create mode 100644 Tests/Navigation/EditJotURLTests.swift create mode 100644 Tests/Navigation/EnableICloudSupportURLTests.swift create mode 100644 Tests/Navigation/JotsPageURLTests.swift create mode 100644 Tests/Navigation/JottreGithubURLTests.swift create mode 100644 Tests/Navigation/RevealFileURLTests.swift create mode 100644 Tests/PageViewController/PageCellSizingStrategyTests.swift create mode 100644 Tests/PageViewController/PageHeaderCellViewModelTests.swift create mode 100644 Tests/SettingsPage/SettingsRepositoryTests.swift create mode 100644 Tests/Utilities/Array+safeIndexTests.swift create mode 100644 Tests/Utilities/AsyncSequenceDebounceTests.swift create mode 100644 Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift diff --git a/Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift b/Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift new file mode 100644 index 0000000..0807bc1 --- /dev/null +++ b/Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift @@ -0,0 +1,81 @@ +import XCTest + +@testable import Jottre + +final class CloudMigrationJotBusinessModelTests: XCTestCase { + + func test_init_givenLocalInfo_isUbiquitousFalseAndIsDownloadedTrue() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + + // When + let model = CloudMigrationJotBusinessModel(jotFileInfo: info) + + // Then + XCTAssertEqual(model.name, "note") + XCTAssertFalse(model.isUbiquitous) + XCTAssertTrue(model.isDownloaded) + XCTAssertFalse(model.isDownloading) + XCTAssertEqual(model.lastModifiedText, "") + } + + func test_init_givenUbiquitousInfoNotDownloaded_isUbiquitousTrueAndIsDownloadedFalse() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .notDownloaded, isDownloading: true) + ) + + // When + let model = CloudMigrationJotBusinessModel(jotFileInfo: info) + + // Then + XCTAssertTrue(model.isUbiquitous) + XCTAssertFalse(model.isDownloaded) + XCTAssertTrue(model.isDownloading) + } + + func test_init_givenModificationDate_formatsLastModifiedText() { + // Given + let date = Date(timeIntervalSince1970: 0) + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: date, + ubiquitousInfo: nil + ) + + // When + let model = CloudMigrationJotBusinessModel(jotFileInfo: info) + + // Then + XCTAssertFalse(model.lastModifiedText.isEmpty) + XCTAssertEqual( + model.lastModifiedText, + DateFormatter.localizedString(from: date, dateStyle: .long, timeStyle: .short) + ) + } + + func test_toJotFileInfo_returnsOriginalInfo() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + + // When + let model = CloudMigrationJotBusinessModel(jotFileInfo: info) + + // Then + XCTAssertEqual(model.toJotFileInfo(), info) + } +} diff --git a/Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift b/Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift new file mode 100644 index 0000000..509f9a4 --- /dev/null +++ b/Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift @@ -0,0 +1,167 @@ +import XCTest + +@testable import Jottre + +final class CloudMigrationRepositoryTests: XCTestCase { + + private static let localInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/local.jot"), + name: "local", + modificationDate: Date(timeIntervalSince1970: 1_000), + ubiquitousInfo: nil + ) + private static let ubiquitousNewer = JotFile.Info( + url: URL(staticString: "file:///cloud/newer.jot"), + name: "newer", + modificationDate: Date(timeIntervalSince1970: 3_000), + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + private static let ubiquitousOlder = JotFile.Info( + url: URL(staticString: "file:///cloud/older.jot"), + name: "older", + modificationDate: Date(timeIntervalSince1970: 2_000), + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + + func test_getJotFiles_yieldsLocalsBeforeUbiquitousAndUbiquitousSortedNewestFirst() async throws { + // Given + let jotFileServiceMock = JotFileServiceMock( + documentsDirectoryContentsProvider: { + AsyncThrowingStream { continuation in + continuation.yield([Self.ubiquitousNewer, Self.localInfo, Self.ubiquitousOlder]) + continuation.finish() + } + } + ) + let repository = CloudMigrationRepository( + ubiquitousFileService: FileServiceMock(), + jotFileService: jotFileServiceMock, + jotFilePreviewImageService: JotFilePreviewImageServiceMock(), + defaultsService: DefaultsServiceMock() + ) + + // When + var iterator = repository.getJotFiles().makeAsyncIterator() + let first = try await XCTUnwrapAsync(try await iterator.next()) + + // Then + XCTAssertEqual(first.map(\.name), ["local", "newer", "older"]) + } + + func test_moveJotFile_forwardsToJotFileService() async throws { + // Given + let moveProviderExpectation = XCTestExpectation(description: "moveProvider is called.") + let jotFileServiceMock = JotFileServiceMock( + moveProvider: { receivedInfo, receivedShouldBecomeUbiquitous in + // Then + XCTAssertEqual(receivedInfo, Self.localInfo) + XCTAssertTrue(receivedShouldBecomeUbiquitous) + moveProviderExpectation.fulfill() + } + ) + let repository = CloudMigrationRepository( + ubiquitousFileService: FileServiceMock(), + jotFileService: jotFileServiceMock, + jotFilePreviewImageService: JotFilePreviewImageServiceMock(), + defaultsService: DefaultsServiceMock() + ) + + // When + try await repository.moveJotFile(jotFileInfo: Self.localInfo, shouldBecomeUbiquitous: true) + + // Then + await fulfillment(of: [moveProviderExpectation], timeout: 0.2) + } + + func test_getShouldShowCloudMigration_givenAlreadyDone_returnsFalse() { + // Given + let defaultsServiceMock = DefaultsServiceMock( + initialValues: [DefaultsKey.hasDoneCloudMigration.description: true] + ) + let repository = CloudMigrationRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { false }), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock(), + defaultsService: defaultsServiceMock + ) + + // Then + XCTAssertFalse(repository.getShouldShowCloudMigration()) + } + + func test_getShouldShowCloudMigration_givenStoredFlagDiffersFromCurrentUbiquitousState_returnsTrue() { + // Given + let defaultsServiceMock = DefaultsServiceMock( + initialValues: [DefaultsKey.isICloudEnabled.description: false] + ) + let repository = CloudMigrationRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { true }), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock(), + defaultsService: defaultsServiceMock + ) + + // Then + XCTAssertTrue(repository.getShouldShowCloudMigration()) + } + + func test_getShouldShowCloudMigration_givenStoredFlagMatchesCurrentUbiquitousState_returnsFalse() { + // Given + let defaultsServiceMock = DefaultsServiceMock( + initialValues: [DefaultsKey.isICloudEnabled.description: true] + ) + let repository = CloudMigrationRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { true }), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock(), + defaultsService: defaultsServiceMock + ) + + // Then + XCTAssertFalse(repository.getShouldShowCloudMigration()) + } + + func test_getShouldShowCloudMigration_givenNoStoredFlagAndUbiquitousDisabled_persistsFalseAndReturnsFalse() { + // Given + let defaultsServiceMock = DefaultsServiceMock() + let repository = CloudMigrationRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { false }), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock(), + defaultsService: defaultsServiceMock + ) + + // When + let result = repository.getShouldShowCloudMigration() + + // Then + XCTAssertFalse(result) + XCTAssertEqual(defaultsServiceMock.getValue(.isICloudEnabled), false) + } + + func test_markCloudMigrationPageDone_setsHasDoneCloudMigrationToTrue() { + // Given + let defaultsServiceMock = DefaultsServiceMock() + let repository = CloudMigrationRepository( + ubiquitousFileService: FileServiceMock(), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock(), + defaultsService: defaultsServiceMock + ) + + // When + repository.markCloudMigrationPageDone() + + // Then + XCTAssertEqual(defaultsServiceMock.getValue(.hasDoneCloudMigration), true) + } +} + +private func XCTUnwrapAsync( + _ expression: @autoclosure () async throws -> T?, + file: StaticString = #filePath, + line: UInt = #line +) async throws -> T { + let value = try await expression() + return try XCTUnwrap(value, file: file, line: line) +} diff --git a/Tests/Defaults/DefaultsContinuationStorageTests.swift b/Tests/Defaults/DefaultsContinuationStorageTests.swift new file mode 100644 index 0000000..9efeb13 --- /dev/null +++ b/Tests/Defaults/DefaultsContinuationStorageTests.swift @@ -0,0 +1,76 @@ +import XCTest + +@testable import Jottre + +final class DefaultsContinuationStorageTests: XCTestCase { + + func test_continuations_givenNoRegistrations_returnsNil() { + // Given + let storage = DefaultsContinuationStorage() + let key = DefaultsKey("none") + + // When + let result = storage.continuations(defaultsKey: key) + + // Then + XCTAssertNil(result) + } + + func test_add_givenContinuationForKey_continuationsReturnsIt() throws { + // Given + let storage = DefaultsContinuationStorage() + let key = DefaultsKey("k") + let stream = AsyncStream { continuation in + storage.add(continuation, defaultsKey: key) + } + // Force the closure to run by creating an iterator. + var iterator = stream.makeAsyncIterator() + _ = iterator + + // When + let result = try XCTUnwrap(storage.continuations(defaultsKey: key)) + + // Then + XCTAssertEqual(result.count, 1) + } + + func test_addMultiple_givenSameKey_continuationsReturnsAll() throws { + // Given + let storage = DefaultsContinuationStorage() + let key = DefaultsKey("k") + let stream1 = AsyncStream { continuation in + storage.add(continuation, defaultsKey: key) + } + let stream2 = AsyncStream { continuation in + storage.add(continuation, defaultsKey: key) + } + var iterator1 = stream1.makeAsyncIterator() + var iterator2 = stream2.makeAsyncIterator() + _ = iterator1 + _ = iterator2 + + // When + let result = try XCTUnwrap(storage.continuations(defaultsKey: key)) + + // Then + XCTAssertEqual(result.count, 2) + } + + func test_continuations_givenDifferentKey_returnsNil() { + // Given + let storage = DefaultsContinuationStorage() + let registeredKey = DefaultsKey("k1") + let otherKey = DefaultsKey("k2") + let stream = AsyncStream { continuation in + storage.add(continuation, defaultsKey: registeredKey) + } + var iterator = stream.makeAsyncIterator() + _ = iterator + + // When + let result = storage.continuations(defaultsKey: otherKey) + + // Then + XCTAssertNil(result) + } +} diff --git a/Tests/Defaults/DefaultsKeyTests.swift b/Tests/Defaults/DefaultsKeyTests.swift new file mode 100644 index 0000000..1cf689a --- /dev/null +++ b/Tests/Defaults/DefaultsKeyTests.swift @@ -0,0 +1,46 @@ +import XCTest + +@testable import Jottre + +final class DefaultsKeyTests: XCTestCase { + + func test_init_givenString_setsDescription() { + // When + let key = DefaultsKey("someKey") + + // Then + XCTAssertEqual(key.description, "someKey") + } + + func test_initStringLiteral_setsDescription() { + // When + let key: DefaultsKey = "literalKey" + + // Then + XCTAssertEqual(key.description, "literalKey") + } + + func test_isICloudEnabled_returnsExpectedDescription() { + // When + let key = DefaultsKey.isICloudEnabled + + // Then + XCTAssertEqual(key.description, "isICloudEnabled") + } + + func test_userInterfaceStyle_returnsExpectedDescription() { + // When + let key = DefaultsKey.userInterfaceStyle + + // Then + XCTAssertEqual(key.description, "userInterfaceStyle") + } + + func test_hasDoneCloudMigration_returnsExpectedDescription() { + // When + let key = DefaultsKey.hasDoneCloudMigration + + // Then + XCTAssertEqual(key.description, "hasDoneCloudMigration") + } +} diff --git a/Tests/Defaults/DefaultsServiceTests.swift b/Tests/Defaults/DefaultsServiceTests.swift new file mode 100644 index 0000000..09969c6 --- /dev/null +++ b/Tests/Defaults/DefaultsServiceTests.swift @@ -0,0 +1,99 @@ +import XCTest + +@testable import Jottre + +final class DefaultsServiceTests: XCTestCase { + + private var userDefaults: UserDefaults! + private var suiteName: String! + + override func setUp() { + super.setUp() + suiteName = "DefaultsServiceTests-\(UUID().uuidString)" + userDefaults = try! XCTUnwrap(UserDefaults(suiteName: suiteName)) + } + + override func tearDown() { + userDefaults.removePersistentDomain(forName: suiteName) + userDefaults = nil + suiteName = nil + super.tearDown() + } + + func test_getValue_givenNoStoredValue_returnsNil() { + // Given + let service = DefaultsService(userDefaults: userDefaults) + + // When + let value: Bool? = service.getValue(DefaultsKey("missing")) + + // Then + XCTAssertNil(value) + } + + func test_set_givenBoolValue_persistsAsRoundTrippableString() throws { + // Given + let service = DefaultsService(userDefaults: userDefaults) + let key = DefaultsKey("flag") + + // When + service.set(key, value: true) + + // Then + let stored = try XCTUnwrap(service.getValue(key)) + XCTAssertTrue(stored) + } + + func test_set_givenNilValue_clearsValue() { + // Given + let service = DefaultsService(userDefaults: userDefaults) + let key = DefaultsKey("count") + service.set(key, value: 42) + + // When + service.set(key, value: nil) + + // Then + XCTAssertNil(service.getValue(key)) + } + + func test_getValueStream_yieldsCurrentValueImmediately() async throws { + // Given + let service = DefaultsService(userDefaults: userDefaults) + let key = DefaultsKey("preset") + service.set(key, value: 7) + + // When + var iterator = service.getValueStream(key).makeAsyncIterator() + let first = try await XCTUnwrapAsync(await iterator.next()) + + // Then + XCTAssertEqual(first, 7) + } + + func test_getValueStream_yieldsValueOnSubsequentSet() async throws { + // Given + let service = DefaultsService(userDefaults: userDefaults) + let key = DefaultsKey("counter") + + var iterator = service.getValueStream(key).makeAsyncIterator() + // Discard initial yield (nil — no stored value) + _ = await iterator.next() + + // When + service.set(key, value: 99) + let next = try await XCTUnwrapAsync(await iterator.next()) + + // Then + XCTAssertEqual(next, 99) + } +} + +private func XCTUnwrapAsync( + _ expression: @autoclosure () async throws -> T?, + file: StaticString = #filePath, + line: UInt = #line +) async throws -> T { + let value = try await expression() + return try XCTUnwrap(value, file: file, line: line) +} diff --git a/Tests/EditJotPage/EditJotRepositoryTests.swift b/Tests/EditJotPage/EditJotRepositoryTests.swift new file mode 100644 index 0000000..fb97a3d --- /dev/null +++ b/Tests/EditJotPage/EditJotRepositoryTests.swift @@ -0,0 +1,151 @@ +@preconcurrency import PencilKit +import XCTest + +@testable import Jottre + +final class EditJotRepositoryTests: XCTestCase { + + func test_ubiquitousInfo_forwardsToUbiquitousFileService() { + // Given + let expectedInfo = UbiquitousInfo(downloadStatus: .current, isDownloading: false) + let url = URL(staticString: "file:///cloud/note.jot") + let repository = EditJotRepository( + ubiquitousFileService: FileServiceMock( + ubiquitousInfoProvider: { receivedURL in + XCTAssertEqual(receivedURL, url) + return expectedInfo + } + ), + jotFileService: JotFileServiceMock(), + jotFileConflictService: JotFileConflictServiceMock() + ) + + // When + let result = repository.ubiquitousInfo(url: url) + + // Then + XCTAssertEqual(result, expectedInfo) + } + + func test_readDrawing_givenValidJotFile_returnsDrawingAndWidth() async throws { + // Given + let drawing = PKDrawing() + let drawingData = drawing.dataRepresentation() + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let repository = EditJotRepository( + ubiquitousFileService: FileServiceMock(), + jotFileService: JotFileServiceMock( + readJotFileProvider: { _ in + JotFile( + info: info, + jot: Jot(version: 3, drawing: drawingData, width: 800) + ) + } + ), + jotFileConflictService: JotFileConflictServiceMock() + ) + + // When + let result = try await repository.readDrawing(jotFileInfo: info) + + // Then + XCTAssertEqual(result.width, 800) + XCTAssertEqual(result.drawing.dataRepresentation(), drawingData) + } + + func test_writeDrawing_writesEncodedDrawingViaJotFileService() async throws { + // Given + let writeProviderExpectation = XCTestExpectation(description: "JotFileServiceMock.writeProvider is called.") + let drawing = PKDrawing() + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let repository = EditJotRepository( + ubiquitousFileService: FileServiceMock(), + jotFileService: JotFileServiceMock( + writeProvider: { jotFile in + // Then + XCTAssertEqual(jotFile.info, info) + XCTAssertEqual(jotFile.jot.drawing, drawing.dataRepresentation()) + writeProviderExpectation.fulfill() + } + ), + jotFileConflictService: JotFileConflictServiceMock() + ) + + // When + try await repository.writeDrawing(jotFileInfo: info, drawing: drawing) + + // Then + await fulfillment(of: [writeProviderExpectation], timeout: 0.2) + } + + func test_getConflictingVersions_forwardsToConflictService() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let expected = [ + JotFileVersion(localizedNameOfSavingComputer: "Mac", info: info) + ] + let repository = EditJotRepository( + ubiquitousFileService: FileServiceMock(), + jotFileService: JotFileServiceMock(), + jotFileConflictService: JotFileConflictServiceMock( + getConfictingVersionsProvider: { receivedInfo in + XCTAssertEqual(receivedInfo, info) + return expected + } + ) + ) + + // When + let result = repository.getConflictingVersions(jotFileInfo: info) + + // Then + XCTAssertEqual(result, expected) + } + + func test_duplicate_forwardsToJotFileService() throws { + // Given + let original = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let duplicated = JotFile.Info( + url: URL(staticString: "file:///tmp/note-1.jot"), + name: "note-1", + modificationDate: nil, + ubiquitousInfo: nil + ) + let repository = EditJotRepository( + ubiquitousFileService: FileServiceMock(), + jotFileService: JotFileServiceMock( + duplicateProvider: { receivedInfo in + XCTAssertEqual(receivedInfo, original) + return duplicated + } + ), + jotFileConflictService: JotFileConflictServiceMock() + ) + + // When + let result = try repository.duplicate(jotFileInfo: original) + + // Then + XCTAssertEqual(result, duplicated) + } +} diff --git a/Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift b/Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift new file mode 100644 index 0000000..d048d95 --- /dev/null +++ b/Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift @@ -0,0 +1,19 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class FeatureRowCellViewModelTests: XCTestCase { + + func test_init_storesSystemImageNameAndText() { + // When + let viewModel = FeatureRowCellViewModel( + systemImageName: "icloud", + text: "Sync across devices" + ) + + // Then + XCTAssertEqual(viewModel.systemImageName, "icloud") + XCTAssertEqual(viewModel.text, "Sync across devices") + } +} diff --git a/Tests/FileService/UbiquitousInfoTests.swift b/Tests/FileService/UbiquitousInfoTests.swift new file mode 100644 index 0000000..135c337 --- /dev/null +++ b/Tests/FileService/UbiquitousInfoTests.swift @@ -0,0 +1,42 @@ +import XCTest + +@testable import Jottre + +final class UbiquitousInfoTests: XCTestCase { + + func test_equality_givenSameValues_returnsEqual() { + // Given + let lhs = UbiquitousInfo(downloadStatus: .current, isDownloading: false) + let rhs = UbiquitousInfo(downloadStatus: .current, isDownloading: false) + + // Then + XCTAssertEqual(lhs, rhs) + } + + func test_equality_givenDifferentDownloadStatus_returnsNotEqual() { + // Given + let lhs = UbiquitousInfo(downloadStatus: .current, isDownloading: false) + let rhs = UbiquitousInfo(downloadStatus: .notDownloaded, isDownloading: false) + + // Then + XCTAssertNotEqual(lhs, rhs) + } + + func test_equality_givenDifferentIsDownloading_returnsNotEqual() { + // Given + let lhs = UbiquitousInfo(downloadStatus: .current, isDownloading: false) + let rhs = UbiquitousInfo(downloadStatus: .current, isDownloading: true) + + // Then + XCTAssertNotEqual(lhs, rhs) + } + + func test_equality_givenNilDownloadStatusOnBoth_returnsEqual() { + // Given + let lhs = UbiquitousInfo(downloadStatus: nil, isDownloading: true) + let rhs = UbiquitousInfo(downloadStatus: nil, isDownloading: true) + + // Then + XCTAssertEqual(lhs, rhs) + } +} diff --git a/Tests/Helpers/URL+staticString.swift b/Tests/Helpers/URL+staticString.swift new file mode 100644 index 0000000..c9dd3bd --- /dev/null +++ b/Tests/Helpers/URL+staticString.swift @@ -0,0 +1,11 @@ +import Foundation + +extension URL { + + init(staticString: StaticString) { + guard let url = URL(string: "\(staticString)") else { + preconditionFailure("Invalid static URL string: \(staticString)") + } + self = url + } +} diff --git a/Tests/Jot/JotFileServiceTests.swift b/Tests/Jot/JotFileServiceTests.swift new file mode 100644 index 0000000..608bfc6 --- /dev/null +++ b/Tests/Jot/JotFileServiceTests.swift @@ -0,0 +1,360 @@ +import XCTest + +@testable import Jottre + +final class JotFileServiceTests: XCTestCase { + + func test_write_givenLocalJotFile_writesEncodedDataToLocalFileService() async throws { + // Given + let writeFileProviderExpectation = XCTestExpectation( + description: "FileServiceMock.writeFileProvider is called." + ) + let expectedFileURL = URL(staticString: "file:///tmp/note.jot") + let jot = Jot.makeEmpty() + let jotFile = JotFile( + info: JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ), + jot: jot + ) + let expectedData = try PropertyListEncoder().encode(jot) + let localFileServiceMock = FileServiceMock( + writeFileProvider: { receivedFileURL, receivedData in + // Then + XCTAssertEqual(receivedFileURL, expectedFileURL) + XCTAssertEqual(receivedData, expectedData) + writeFileProviderExpectation.fulfill() + } + ) + let ubiquitousFileServiceMock = FileServiceMock( + writeFileProvider: { _, _ in + XCTFail("Ubiquitous file service should not be used for local jot files.") + } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + try jotFileService.write(jotFile: jotFile) + + // Then + await fulfillment(of: [writeFileProviderExpectation], timeout: 0.2) + } + + func test_write_givenUbiquitousJotFile_writesEncodedDataToUbiquitousFileService() async throws { + // Given + let writeFileProviderExpectation = XCTestExpectation(description: "Ubiquitous writeFileProvider is called.") + let expectedFileURL = URL(staticString: "file:///cloud/note.jot") + let jot = Jot.makeEmpty() + let jotFile = JotFile( + info: JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo( + downloadStatus: .current, + isDownloading: false + ) + ), + jot: jot + ) + let localFileServiceMock = FileServiceMock( + writeFileProvider: { _, _ in + XCTFail("Local file service should not be used for ubiquitous jot files.") + } + ) + let ubiquitousFileServiceMock = FileServiceMock( + writeFileProvider: { receivedFileURL, _ in + // Then + XCTAssertEqual(receivedFileURL, expectedFileURL) + writeFileProviderExpectation.fulfill() + } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + try jotFileService.write(jotFile: jotFile) + + // Then + await fulfillment(of: [writeFileProviderExpectation], timeout: 0.2) + } + + func test_readJotFile_givenLocalJotFileInfo_decodesDataFromLocalFileService() async throws { + // Given + let readFileProviderExpectation = XCTestExpectation(description: "Local readFileProvider is called.") + let expectedFileURL = URL(staticString: "file:///tmp/note.jot") + let expectedJot = Jot.makeEmpty() + let encodedData = try PropertyListEncoder().encode(expectedJot) + let localFileServiceMock = FileServiceMock( + readFileProvider: { receivedFileURL in + // Then + XCTAssertEqual(receivedFileURL, expectedFileURL) + readFileProviderExpectation.fulfill() + return encodedData + } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: FileServiceMock() + ) + + // When + let jotFile = try jotFileService.readJotFile( + jotFileInfo: JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + ) + + // Then + XCTAssertEqual(jotFile.jot.drawing, expectedJot.drawing) + XCTAssertEqual(jotFile.jot.width, expectedJot.width) + XCTAssertEqual(jotFile.jot.version, expectedJot.version) + await fulfillment(of: [readFileProviderExpectation], timeout: 0.2) + } + + func test_remove_givenLocalJotFileInfo_callsRemoveOnLocalFileService() async throws { + // Given + let removeFileProviderExpectation = XCTestExpectation(description: "Local removeFileProvider is called.") + let expectedFileURL = URL(staticString: "file:///tmp/note.jot") + let localFileServiceMock = FileServiceMock( + removeFileProvider: { receivedFileURL in + // Then + XCTAssertEqual(receivedFileURL, expectedFileURL) + removeFileProviderExpectation.fulfill() + } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: FileServiceMock() + ) + + // When + try jotFileService.remove( + jotFileInfo: JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + ) + + // Then + await fulfillment(of: [removeFileProviderExpectation], timeout: 0.2) + } + + func test_rename_givenLocalJotFileInfo_movesToNewURLAndReturnsUpdatedInfo() async throws { + // Given + let moveFileProviderExpectation = XCTestExpectation(description: "Local moveFileProvider is called.") + let originalFileURL = URL(staticString: "file:///tmp/old.jot") + let expectedNewFileURL = URL(staticString: "file:///tmp/new.jot") + let localFileServiceMock = FileServiceMock( + moveFileProvider: { receivedFileURL, receivedNewFileURL in + // Then + XCTAssertEqual(receivedFileURL, originalFileURL) + XCTAssertEqual(receivedNewFileURL, expectedNewFileURL) + moveFileProviderExpectation.fulfill() + } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: FileServiceMock() + ) + + // When + let renamed = try jotFileService.rename( + jotFileInfo: JotFile.Info( + url: originalFileURL, + name: "old", + modificationDate: nil, + ubiquitousInfo: nil + ), + newName: "new" + ) + + // Then + XCTAssertEqual(renamed.url, expectedNewFileURL) + XCTAssertEqual(renamed.name, "new") + await fulfillment(of: [moveFileProviderExpectation], timeout: 0.2) + } + + func test_duplicate_givenLocalJotFileInfo_returnsDuplicatedInfo() async throws { + // Given + let duplicateFileProviderExpectation = XCTestExpectation(description: "Local duplicateFileProvider is called.") + let originalFileURL = URL(staticString: "file:///tmp/note.jot") + let duplicatedFileURL = URL(staticString: "file:///tmp/note-1.jot") + let localFileServiceMock = FileServiceMock( + duplicateFileProvider: { receivedFileURL in + // Then + XCTAssertEqual(receivedFileURL, originalFileURL) + duplicateFileProviderExpectation.fulfill() + return duplicatedFileURL + } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: FileServiceMock() + ) + + // When + let duplicated = try jotFileService.duplicate( + jotFileInfo: JotFile.Info( + url: originalFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + ) + + // Then + XCTAssertEqual(duplicated.url, duplicatedFileURL) + XCTAssertEqual(duplicated.name, "note-1") + await fulfillment(of: [duplicateFileProviderExpectation], timeout: 0.2) + } + + func test_move_givenShouldBecomeUbiquitous_movesIntoUbiquitousDocumentsDirectory() async throws { + // Given + let moveFileProviderExpectation = XCTestExpectation(description: "Ubiquitous moveFileProvider is called.") + let originalFileURL = URL(staticString: "file:///tmp/note.jot") + let ubiquitousDocumentsDirectory = URL(staticString: "file:///cloud/Documents/") + let expectedNewFileURL = ubiquitousDocumentsDirectory.appendingPathComponent("note.jot", isDirectory: false) + let ubiquitousFileServiceMock = FileServiceMock( + documentsDirectoryProvider: { ubiquitousDocumentsDirectory }, + moveFileProvider: { receivedFileURL, receivedNewFileURL in + // Then + XCTAssertEqual(receivedFileURL, originalFileURL) + XCTAssertEqual(receivedNewFileURL, expectedNewFileURL) + moveFileProviderExpectation.fulfill() + } + ) + let jotFileService = JotFileService( + localFileService: FileServiceMock(), + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + try await jotFileService.move( + jotFileInfo: JotFile.Info( + url: originalFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ), + shouldBecomeUbiquitous: true + ) + + // Then + await fulfillment(of: [moveFileProviderExpectation], timeout: 0.2) + } + + func test_readJotFile_givenUbiquitousJotFileInfo_decodesDataFromUbiquitousFileService() async throws { + // Given + let readFileProviderExpectation = XCTestExpectation(description: "Ubiquitous readFileProvider is called.") + let expectedFileURL = URL(staticString: "file:///cloud/note.jot") + let expectedJot = Jot.makeEmpty() + let encodedData = try PropertyListEncoder().encode(expectedJot) + let ubiquitousFileServiceMock = FileServiceMock( + readFileProvider: { receivedFileURL in + // Then + XCTAssertEqual(receivedFileURL, expectedFileURL) + readFileProviderExpectation.fulfill() + return encodedData + } + ) + let jotFileService = JotFileService( + localFileService: FileServiceMock( + readFileProvider: { _ in + XCTFail("Local file service should not be used for ubiquitous jot files.") + return Data() + } + ), + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + _ = try jotFileService.readJotFile( + jotFileInfo: JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + ) + + // Then + await fulfillment(of: [readFileProviderExpectation], timeout: 0.2) + } + + func test_remove_givenUbiquitousJotFileInfo_callsRemoveOnUbiquitousFileService() async throws { + // Given + let removeFileProviderExpectation = XCTestExpectation(description: "Ubiquitous removeFileProvider is called.") + let expectedFileURL = URL(staticString: "file:///cloud/note.jot") + let ubiquitousFileServiceMock = FileServiceMock( + removeFileProvider: { receivedFileURL in + // Then + XCTAssertEqual(receivedFileURL, expectedFileURL) + removeFileProviderExpectation.fulfill() + } + ) + let jotFileService = JotFileService( + localFileService: FileServiceMock( + removeFileProvider: { _ in + XCTFail("Local file service should not be used for ubiquitous jot files.") + } + ), + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + try jotFileService.remove( + jotFileInfo: JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + ) + + // Then + await fulfillment(of: [removeFileProviderExpectation], timeout: 0.2) + } + + func test_move_givenDocumentsDirectoryUnresolved_throwsCouldNotResolveFailure() async { + // Given + let localFileServiceMock = FileServiceMock( + documentsDirectoryProvider: { nil } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: FileServiceMock() + ) + + // When / Then + do { + try await jotFileService.move( + jotFileInfo: JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ), + shouldBecomeUbiquitous: false + ) + XCTFail("Expected JotFileService.Failure.couldNotResolveDocumentsDirectory.") + } catch JotFileService.Failure.couldNotResolveDocumentsDirectory { + // Expected + } catch { + XCTFail("Unexpected error: \(error)") + } + } +} diff --git a/Tests/Jot/JotFileTests.swift b/Tests/Jot/JotFileTests.swift new file mode 100644 index 0000000..5734ec1 --- /dev/null +++ b/Tests/Jot/JotFileTests.swift @@ -0,0 +1,49 @@ +import XCTest + +@testable import Jottre + +final class JotFileTests: XCTestCase { + + func test_infoInit_givenURLWithJotExtension_succeedsAndDerivesNameFromURL() throws { + // Given + let url = URL(staticString: "file:///tmp/note.jot") + + // When + let info = try XCTUnwrap( + JotFile.Info( + url: url, + modificationDate: nil, + ubiquitousInfo: nil + ) + ) + + // Then + XCTAssertEqual(info.name, "note") + XCTAssertEqual(info.url, url) + } + + func test_infoInit_givenURLWithNonJotExtension_returnsNil() { + // Given + let url = URL(staticString: "file:///tmp/note.txt") + + // When + let info = JotFile.Info( + url: url, + modificationDate: nil, + ubiquitousInfo: nil + ) + + // Then + XCTAssertNil(info) + } + + func test_makeEmptyJot_returnsVersionThreeWithDefaultWidth() { + // When + let jot = Jot.makeEmpty() + + // Then + XCTAssertEqual(jot.version, 3) + XCTAssertEqual(jot.width, 1200) + XCTAssertFalse(jot.drawing.isEmpty) + } +} diff --git a/Tests/JotConflictPage/JotConflictBusinessModelTests.swift b/Tests/JotConflictPage/JotConflictBusinessModelTests.swift new file mode 100644 index 0000000..427a670 --- /dev/null +++ b/Tests/JotConflictPage/JotConflictBusinessModelTests.swift @@ -0,0 +1,77 @@ +import XCTest + +@testable import Jottre + +final class JotConflictBusinessModelTests: XCTestCase { + + func test_init_givenSavingComputerName_usesAsLastEditedDateString() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let version = JotFileVersion( + localizedNameOfSavingComputer: "Anton's Mac", + info: info + ) + + // When + let model = JotConflictBusinessModel( + name: "label", + jotFileInfo: info, + jotFileVersion: version + ) + + // Then + XCTAssertEqual(model.name, "label") + XCTAssertEqual(model.lastEditedDateString, "Anton's Mac") + XCTAssertEqual(model.jotFileInfo, info) + } + + func test_init_givenNilSavingComputerName_returnsNotApplicableString() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let version = JotFileVersion( + localizedNameOfSavingComputer: nil, + info: info + ) + + // When + let model = JotConflictBusinessModel( + name: "label", + jotFileInfo: info, + jotFileVersion: version + ) + + // Then + XCTAssertEqual(model.lastEditedDateString, "n/a") + } + + func test_toJotFileVersion_returnsOriginalVersion() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let version = JotFileVersion(localizedNameOfSavingComputer: nil, info: info) + + // When + let model = JotConflictBusinessModel( + name: "label", + jotFileInfo: info, + jotFileVersion: version + ) + + // Then + XCTAssertEqual(model.toJotFileVersion(), version) + } +} diff --git a/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift b/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift new file mode 100644 index 0000000..0cb3dba --- /dev/null +++ b/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift @@ -0,0 +1,114 @@ +import XCTest + +@testable import Jottre + +final class CachedJotFilePreviewImageServiceTests: XCTestCase { + + private let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: Date(timeIntervalSince1970: 1_000), + ubiquitousInfo: nil + ) + + func test_getPreviewImageData_givenColdCache_callsUnderlyingServiceAndReturnsItsData() async throws { + // Given + let underlyingExpectation = XCTestExpectation(description: "Underlying service is called.") + let expectedData = Data([1, 2, 3]) + let underlying = JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { _, _, _ in + underlyingExpectation.fulfill() + return expectedData + } + ) + let service = CachedJotFilePreviewImageService( + localFileService: FileServiceMock( + readFileProvider: { _ in throw NSError(domain: "noDiskCache", code: 0) } + ), + jotFilePreviewImageService: underlying + ) + + // When + let data = try await service.getPreviewImageData( + jotFileInfo: info, + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + XCTAssertEqual(data, expectedData) + await fulfillment(of: [underlyingExpectation], timeout: 0.5) + } + + func test_getPreviewImageData_givenSecondCallWithSameKey_servesFromMemoryCache() async throws { + // Given + let underlyingCallCount = LockIsolated(0) + let expectedData = Data([9, 8, 7]) + let underlying = JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { _, _, _ in + underlyingCallCount.withValue { $0 += 1 } + return expectedData + } + ) + let service = CachedJotFilePreviewImageService( + localFileService: FileServiceMock( + readFileProvider: { _ in throw NSError(domain: "noDiskCache", code: 0) } + ), + jotFilePreviewImageService: underlying + ) + + // When + _ = try await service.getPreviewImageData(jotFileInfo: info, userInterfaceStyle: .light, displayScale: 2.0) + let second = try await service.getPreviewImageData( + jotFileInfo: info, + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + XCTAssertEqual(second, expectedData) + XCTAssertEqual(underlyingCallCount.value, 1) + } + + func test_getPreviewImageData_givenDiskCacheHit_skipsUnderlyingService() async throws { + // Given + let cachedData = Data([42]) + let underlying = JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { _, _, _ in + XCTFail("Underlying service should not be called when the disk cache is warm.") + return Data() + } + ) + let service = CachedJotFilePreviewImageService( + localFileService: FileServiceMock( + readFileProvider: { _ in cachedData } + ), + jotFilePreviewImageService: underlying + ) + + // When + let data = try await service.getPreviewImageData( + jotFileInfo: info, + userInterfaceStyle: .dark, + displayScale: 3.0 + ) + + // Then + XCTAssertEqual(data, cachedData) + } +} + +final class LockIsolated: @unchecked Sendable { + private let lock = NSLock() + private var _value: Value + + init(_ value: Value) { _value = value } + + var value: Value { + lock.withLock { _value } + } + + func withValue(_ work: (inout Value) -> Void) { + lock.withLock { work(&_value) } + } +} diff --git a/Tests/JotsPage/CreateJotRepositoryTests.swift b/Tests/JotsPage/CreateJotRepositoryTests.swift new file mode 100644 index 0000000..c339163 --- /dev/null +++ b/Tests/JotsPage/CreateJotRepositoryTests.swift @@ -0,0 +1,124 @@ +import XCTest + +@testable import Jottre + +final class CreateJotRepositoryTests: XCTestCase { + + func test_createJot_givenUbiquitousDocumentsDirectoryAvailable_writesToUbiquitousService() async throws { + // Given + let writeProviderExpectation = XCTestExpectation(description: "JotFileServiceMock.writeProvider is called.") + let ubiquitousDocumentsDirectory = URL(staticString: "file:///cloud/Documents/") + let jotFileServiceMock = JotFileServiceMock( + writeProvider: { jotFile in + // Then + XCTAssertEqual(jotFile.info.name, "note") + XCTAssertNotNil(jotFile.info.ubiquitousInfo) + XCTAssertEqual( + jotFile.info.url, + ubiquitousDocumentsDirectory.appendingPathComponent("note", isDirectory: false) + .appendingPathExtension("jot") + ) + writeProviderExpectation.fulfill() + } + ) + let repository = CreateJotRepository( + localFileService: FileServiceMock( + documentsDirectoryProvider: { + XCTFail("Local file service should not be used when ubiquitous is available.") + return nil + } + ), + ubiquitousFileService: FileServiceMock( + documentsDirectoryProvider: { ubiquitousDocumentsDirectory } + ), + jotFileService: jotFileServiceMock + ) + + // When + let info = try await repository.createJot(name: "note") + + // Then + XCTAssertNotNil(info.ubiquitousInfo) + await fulfillment(of: [writeProviderExpectation], timeout: 0.2) + } + + func test_createJot_givenOnlyLocalDocumentsDirectoryAvailable_writesToLocalService() async throws { + // Given + let writeProviderExpectation = XCTestExpectation(description: "JotFileServiceMock.writeProvider is called.") + let localDocumentsDirectory = URL(staticString: "file:///local/Documents/") + let jotFileServiceMock = JotFileServiceMock( + writeProvider: { jotFile in + // Then + XCTAssertNil(jotFile.info.ubiquitousInfo) + XCTAssertEqual( + jotFile.info.url, + localDocumentsDirectory.appendingPathComponent("note", isDirectory: false).appendingPathExtension( + "jot" + ) + ) + writeProviderExpectation.fulfill() + } + ) + let repository = CreateJotRepository( + localFileService: FileServiceMock( + documentsDirectoryProvider: { localDocumentsDirectory } + ), + ubiquitousFileService: FileServiceMock( + documentsDirectoryProvider: { nil } + ), + jotFileService: jotFileServiceMock + ) + + // When + let info = try await repository.createJot(name: "note") + + // Then + XCTAssertNil(info.ubiquitousInfo) + await fulfillment(of: [writeProviderExpectation], timeout: 0.2) + } + + func test_createJot_givenNoDocumentsDirectoryAvailable_throwsCouldNotCreateFile() async { + // Given + let repository = CreateJotRepository( + localFileService: FileServiceMock(documentsDirectoryProvider: { nil }), + ubiquitousFileService: FileServiceMock(documentsDirectoryProvider: { nil }), + jotFileService: JotFileServiceMock() + ) + + // When / Then + do { + _ = try await repository.createJot(name: "note") + XCTFail("Expected CreateJotRepository.Failure.couldNotCreateFile.") + } catch CreateJotRepository.Failure.couldNotCreateFile { + // Expected + } catch { + XCTFail("Unexpected error: \(error)") + } + } + + func test_createJot_givenFileAlreadyExists_throwsFileExists() async { + // Given + let repository = CreateJotRepository( + localFileService: FileServiceMock(documentsDirectoryProvider: { nil }), + ubiquitousFileService: FileServiceMock( + documentsDirectoryProvider: { URL(staticString: "file:///cloud/Documents/") }, + fileExistsProvider: { _ in true } + ), + jotFileService: JotFileServiceMock( + writeProvider: { _ in + XCTFail("Should not write when file already exists.") + } + ) + ) + + // When / Then + do { + _ = try await repository.createJot(name: "note") + XCTFail("Expected CreateJotRepository.Failure.fileExists.") + } catch CreateJotRepository.Failure.fileExists { + // Expected + } catch { + XCTFail("Unexpected error: \(error)") + } + } +} diff --git a/Tests/JotsPage/DeleteJotRepositoryTests.swift b/Tests/JotsPage/DeleteJotRepositoryTests.swift new file mode 100644 index 0000000..61e53bd --- /dev/null +++ b/Tests/JotsPage/DeleteJotRepositoryTests.swift @@ -0,0 +1,31 @@ +import XCTest + +@testable import Jottre + +final class DeleteJotRepositoryTests: XCTestCase { + + func test_deleteJot_forwardsToJotFileServiceRemove() async throws { + // Given + let removeProviderExpectation = XCTestExpectation(description: "JotFileServiceMock.removeProvider is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let jotFileServiceMock = JotFileServiceMock( + removeProvider: { receivedInfo in + // Then + XCTAssertEqual(receivedInfo, info) + removeProviderExpectation.fulfill() + } + ) + let repository = DeleteJotRepository(jotFileService: jotFileServiceMock) + + // When + try repository.deleteJot(jotFileInfo: info) + + // Then + await fulfillment(of: [removeProviderExpectation], timeout: 0.2) + } +} diff --git a/Tests/JotsPage/EmptyStateCellViewModelTests.swift b/Tests/JotsPage/EmptyStateCellViewModelTests.swift new file mode 100644 index 0000000..2e6dfbc --- /dev/null +++ b/Tests/JotsPage/EmptyStateCellViewModelTests.swift @@ -0,0 +1,29 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class EmptyStateCellViewModelTests: XCTestCase { + + func test_init_storesTitle() { + // When + let viewModel = EmptyStateCellViewModel(title: "Nothing here yet") + + // Then + XCTAssertEqual(viewModel.title, "Nothing here yet") + } + + func test_handleContextMenuConfiguration_returnsNilByDefault() { + // Given + let viewModel = EmptyStateCellViewModel(title: "irrelevant") + + // When + let configuration = viewModel.handleContextMenuConfiguration( + point: .zero, + sourceView: UIView() + ) + + // Then + XCTAssertNil(configuration) + } +} diff --git a/Tests/JotsPage/JotBusinessModelTests.swift b/Tests/JotsPage/JotBusinessModelTests.swift new file mode 100644 index 0000000..e46c311 --- /dev/null +++ b/Tests/JotsPage/JotBusinessModelTests.swift @@ -0,0 +1,75 @@ +import XCTest + +@testable import Jottre + +final class JotBusinessModelTests: XCTestCase { + + func test_init_givenLocalJotFileInfo_isDownloadedTrueAndIsDownloadingFalse() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + + // When + let model = JotBusinessModel(jotFileInfo: jotFileInfo) + + // Then + XCTAssertEqual(model.name, "note") + XCTAssertTrue(model.isDownloaded) + XCTAssertFalse(model.isDownloading) + } + + func test_init_givenUbiquitousInfoWithNotDownloaded_isDownloadedFalse() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .notDownloaded, isDownloading: true) + ) + + // When + let model = JotBusinessModel(jotFileInfo: jotFileInfo) + + // Then + XCTAssertFalse(model.isDownloaded) + XCTAssertTrue(model.isDownloading) + } + + func test_init_givenUbiquitousInfoWithDownloaded_isDownloadedTrue() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .downloaded, isDownloading: false) + ) + + // When + let model = JotBusinessModel(jotFileInfo: jotFileInfo) + + // Then + XCTAssertTrue(model.isDownloaded) + XCTAssertFalse(model.isDownloading) + } + + func test_toJotFileInfo_returnsOriginalInfo() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let model = JotBusinessModel(jotFileInfo: jotFileInfo) + + // When + let result = model.toJotFileInfo() + + // Then + XCTAssertEqual(result, jotFileInfo) + } +} diff --git a/Tests/JotsPage/JotMenuConfigurationFactoryTests.swift b/Tests/JotsPage/JotMenuConfigurationFactoryTests.swift new file mode 100644 index 0000000..3002897 --- /dev/null +++ b/Tests/JotsPage/JotMenuConfigurationFactoryTests.swift @@ -0,0 +1,133 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class JotMenuConfigurationFactoryTests: XCTestCase { + + func test_make_givenNoOpenInNewWindow_producesRenameDuplicateDeleteRevealAndShareGroup() { + // Given + let factory = JotMenuConfigurationFactory() + + // When + let configurations = factory.make( + onShare: { _, _ in }, + onRename: {}, + onDuplicate: {}, + onDelete: {}, + onShowInFiles: {} + ) + let resolved = configurations.make(popoverAnchorProvider: { nil }) + + // Then + XCTAssertEqual(resolved.count, 5) + XCTAssertActionAt(resolved, index: 0, expectedSystemImage: "pencil") + XCTAssertActionAt(resolved, index: 1, expectedSystemImage: "plus.square.on.square") + XCTAssertActionAt(resolved, index: 2, expectedSystemImage: "trash", expectedDestructive: true) + XCTAssertActionAt(resolved, index: 3, expectedSystemImage: "folder") + XCTAssertGroupAt(resolved, index: 4, expectedActionCount: 3) + } + + func test_make_givenOpenInNewWindow_prependsOpenInNewWindowAction() { + // Given + let factory = JotMenuConfigurationFactory() + + // When + let configurations = factory.make( + onShare: { _, _ in }, + onRename: {}, + onDuplicate: {}, + onDelete: {}, + onShowInFiles: {}, + onOpenInNewWindow: {} + ) + let resolved = configurations.make(popoverAnchorProvider: { nil }) + + // Then + XCTAssertEqual(resolved.count, 6) + XCTAssertActionAt(resolved, index: 0, expectedSystemImage: "plus.app") + XCTAssertActionAt(resolved, index: 1, expectedSystemImage: "pencil") + } + + func test_make_actionHandlers_invokeCorrespondingClosures() async { + // Given + let onRenameExpectation = XCTestExpectation(description: "onRename is called.") + let onDuplicateExpectation = XCTestExpectation(description: "onDuplicate is called.") + let onDeleteExpectation = XCTestExpectation(description: "onDelete is called.") + let onShowInFilesExpectation = XCTestExpectation(description: "onShowInFiles is called.") + let onShareExpectation = XCTestExpectation(description: "onShare is called for each format.") + onShareExpectation.expectedFulfillmentCount = 3 + + let factory = JotMenuConfigurationFactory() + + // When + let configurations = factory.make( + onShare: { _, _ in onShareExpectation.fulfill() }, + onRename: { onRenameExpectation.fulfill() }, + onDuplicate: { onDuplicateExpectation.fulfill() }, + onDelete: { onDeleteExpectation.fulfill() }, + onShowInFiles: { onShowInFilesExpectation.fulfill() } + ) + let resolved = configurations.make(popoverAnchorProvider: { nil }) + + invokeAction(resolved[0]) + invokeAction(resolved[1]) + invokeAction(resolved[2]) + invokeAction(resolved[3]) + if case let .group(group) = resolved[4] { + for action in group.actions { + action.handler() + } + } + + // Then + await fulfillment( + of: [ + onRenameExpectation, + onDuplicateExpectation, + onDeleteExpectation, + onShowInFilesExpectation, + onShareExpectation, + ], + timeout: 0.2 + ) + } + + private func invokeAction(_ configuration: JotMenuConfiguration) { + if case let .action(action) = configuration { + action.handler() + } else { + XCTFail("Expected .action, got \(configuration).") + } + } + + private func XCTAssertActionAt( + _ configurations: [JotMenuConfiguration], + index: Int, + expectedSystemImage: String, + expectedDestructive: Bool = false, + file: StaticString = #filePath, + line: UInt = #line + ) { + guard case let .action(action) = configurations[index] else { + XCTFail("Expected .action at index \(index)", file: file, line: line) + return + } + XCTAssertEqual(action.systemImageName, expectedSystemImage, file: file, line: line) + XCTAssertEqual(action.isDestructive, expectedDestructive, file: file, line: line) + } + + private func XCTAssertGroupAt( + _ configurations: [JotMenuConfiguration], + index: Int, + expectedActionCount: Int, + file: StaticString = #filePath, + line: UInt = #line + ) { + guard case let .group(group) = configurations[index] else { + XCTFail("Expected .group at index \(index)", file: file, line: line) + return + } + XCTAssertEqual(group.actions.count, expectedActionCount, file: file, line: line) + } +} diff --git a/Tests/JotsPage/JotsRepositoryTests.swift b/Tests/JotsPage/JotsRepositoryTests.swift new file mode 100644 index 0000000..39b58c8 --- /dev/null +++ b/Tests/JotsPage/JotsRepositoryTests.swift @@ -0,0 +1,194 @@ +import XCTest + +@testable import Jottre + +final class JotsRepositoryTests: XCTestCase { + + func test_getJotFiles_givenJotFileInfos_emitsThemSortedByModificationDateDescending() async throws { + // Given + let older = JotFile.Info( + url: URL(staticString: "file:///tmp/older.jot"), + name: "older", + modificationDate: Date(timeIntervalSince1970: 1_000), + ubiquitousInfo: nil + ) + let newer = JotFile.Info( + url: URL(staticString: "file:///tmp/newer.jot"), + name: "newer", + modificationDate: Date(timeIntervalSince1970: 2_000), + ubiquitousInfo: nil + ) + let undated = JotFile.Info( + url: URL(staticString: "file:///tmp/undated.jot"), + name: "undated", + modificationDate: nil, + ubiquitousInfo: nil + ) + let jotFileServiceMock = JotFileServiceMock( + documentsDirectoryContentsProvider: { + AsyncThrowingStream { continuation in + continuation.yield([older, newer, undated]) + continuation.finish() + } + } + ) + let repository = JotsRepository( + ubiquitousFileService: FileServiceMock(), + applicationService: await ApplicationServiceMock(), + deviceService: await DeviceServiceMock(), + jotFileService: jotFileServiceMock, + jotFilePreviewImageService: JotFilePreviewImageServiceMock() + ) + + // When + var iterator = repository.getJotFiles().makeAsyncIterator() + let first = try await XCTUnwrapAsync(try await iterator.next()) + + // Then + XCTAssertEqual(first.map(\.name), ["newer", "older", "undated"]) + } + + func test_shouldShowEnableICloudButton_givenUbiquitousServiceDisabled_returnsTrue() async { + // Given + let repository = JotsRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { false }), + applicationService: await ApplicationServiceMock(), + deviceService: await DeviceServiceMock(), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock() + ) + + // Then + XCTAssertTrue(repository.shouldShowEnableICloudButton()) + } + + func test_shouldShowEnableICloudButton_givenUbiquitousServiceEnabled_returnsFalse() async { + // Given + let repository = JotsRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { true }), + applicationService: await ApplicationServiceMock(), + deviceService: await DeviceServiceMock(), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock() + ) + + // Then + XCTAssertFalse(repository.shouldShowEnableICloudButton()) + } + + func test_duplicate_forwardsToJotFileService() async throws { + // Given + let duplicateProviderExpectation = XCTestExpectation( + description: "JotFileServiceMock.duplicateProvider is called." + ) + let inputInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let expectedDuplicatedInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note-1.jot"), + name: "note-1", + modificationDate: nil, + ubiquitousInfo: nil + ) + let jotFileServiceMock = JotFileServiceMock( + duplicateProvider: { receivedInfo in + // Then + XCTAssertEqual(receivedInfo, inputInfo) + duplicateProviderExpectation.fulfill() + return expectedDuplicatedInfo + } + ) + let repository = JotsRepository( + ubiquitousFileService: FileServiceMock(), + applicationService: await ApplicationServiceMock(), + deviceService: await DeviceServiceMock(), + jotFileService: jotFileServiceMock, + jotFilePreviewImageService: JotFilePreviewImageServiceMock() + ) + + // When + let result = try repository.duplicate(jotFileInfo: inputInfo) + + // Then + XCTAssertEqual(result, expectedDuplicatedInfo) + await fulfillment(of: [duplicateProviderExpectation], timeout: 0.2) + } + + func test_download_callsStartDownloadOnUbiquitousFileServiceWithJotFileURL() async throws { + // Given + let startDownloadProviderExpectation = XCTestExpectation( + description: "Ubiquitous startDownloadProvider is called." + ) + let expectedFileURL = URL(staticString: "file:///cloud/note.jot") + let ubiquitousFileServiceMock = FileServiceMock( + startDownloadProvider: { receivedFileURL in + // Then + XCTAssertEqual(receivedFileURL, expectedFileURL) + startDownloadProviderExpectation.fulfill() + } + ) + let repository = JotsRepository( + ubiquitousFileService: ubiquitousFileServiceMock, + applicationService: await ApplicationServiceMock(), + deviceService: await DeviceServiceMock(), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock() + ) + + // When + try repository.download( + jotFileInfo: JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .notDownloaded, isDownloading: false) + ) + ) + + // Then + await fulfillment(of: [startDownloadProviderExpectation], timeout: 0.2) + } + + func test_getPreviewImage_givenServiceThrows_returnsNil() async throws { + // Given + let jotFilePreviewImageServiceMock = JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { _, _, _ in + throw NSError(domain: "test", code: 0) + } + ) + let repository = JotsRepository( + ubiquitousFileService: FileServiceMock(), + applicationService: await ApplicationServiceMock(), + deviceService: await DeviceServiceMock(), + jotFileService: JotFileServiceMock(), + jotFilePreviewImageService: jotFilePreviewImageServiceMock + ) + + // When + let image = await repository.getPreviewImage( + jotFileInfo: JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ), + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + XCTAssertNil(image) + } +} + +private func XCTUnwrapAsync( + _ expression: @autoclosure () async throws -> T?, + file: StaticString = #filePath, + line: UInt = #line +) async throws -> T { + let value = try await expression() + return try XCTUnwrap(value, file: file, line: line) +} diff --git a/Tests/JotsPage/RenameJotRepositoryTests.swift b/Tests/JotsPage/RenameJotRepositoryTests.swift new file mode 100644 index 0000000..3569139 --- /dev/null +++ b/Tests/JotsPage/RenameJotRepositoryTests.swift @@ -0,0 +1,40 @@ +import XCTest + +@testable import Jottre + +final class RenameJotRepositoryTests: XCTestCase { + + func test_rename_forwardsArgumentsToJotFileServiceAndReturnsResult() async throws { + // Given + let renameProviderExpectation = XCTestExpectation(description: "JotFileServiceMock.renameProvider is called.") + let inputInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/old.jot"), + name: "old", + modificationDate: nil, + ubiquitousInfo: nil + ) + let expectedRenamedInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/new.jot"), + name: "new", + modificationDate: nil, + ubiquitousInfo: nil + ) + let jotFileServiceMock = JotFileServiceMock( + renameProvider: { receivedInfo, receivedName in + // Then + XCTAssertEqual(receivedInfo, inputInfo) + XCTAssertEqual(receivedName, "new") + renameProviderExpectation.fulfill() + return expectedRenamedInfo + } + ) + let repository = RenameJotRepository(jotFileService: jotFileServiceMock) + + // When + let result = try repository.rename(jotFileInfo: inputInfo, newName: "new") + + // Then + XCTAssertEqual(result, expectedRenamedInfo) + await fulfillment(of: [renameProviderExpectation], timeout: 0.2) + } +} diff --git a/Tests/Mocks/ApplicationServiceMock.swift b/Tests/Mocks/ApplicationServiceMock.swift new file mode 100644 index 0000000..c012c6f --- /dev/null +++ b/Tests/Mocks/ApplicationServiceMock.swift @@ -0,0 +1,25 @@ +import Foundation + +@testable import Jottre + +@MainActor +final class ApplicationServiceMock: ApplicationServiceProtocol { + + private let supportsMultipleScenesProvider: @MainActor () -> Bool + private let openProvider: @MainActor (_ url: URL) -> Void + private let canOpenProvider: @MainActor (_ url: URL) -> Bool + + init( + supportsMultipleScenesProvider: @MainActor @escaping () -> Bool = { false }, + openProvider: @MainActor @escaping (_ url: URL) -> Void = { _ in }, + canOpenProvider: @MainActor @escaping (_ url: URL) -> Bool = { _ in true } + ) { + self.supportsMultipleScenesProvider = supportsMultipleScenesProvider + self.openProvider = openProvider + self.canOpenProvider = canOpenProvider + } + + func supportsMultipleScenes() -> Bool { supportsMultipleScenesProvider() } + func open(url: URL) { openProvider(url) } + func canOpen(url: URL) -> Bool { canOpenProvider(url) } +} diff --git a/Tests/Mocks/BundleServiceMock.swift b/Tests/Mocks/BundleServiceMock.swift new file mode 100644 index 0000000..9e510bc --- /dev/null +++ b/Tests/Mocks/BundleServiceMock.swift @@ -0,0 +1,12 @@ +@testable import Jottre + +final class BundleServiceMock: BundleServiceProtocol { + + private let shortVersionStringProvider: @Sendable () -> String? + + init(shortVersionStringProvider: @Sendable @escaping () -> String? = { nil }) { + self.shortVersionStringProvider = shortVersionStringProvider + } + + func shortVersionString() -> String? { shortVersionStringProvider() } +} diff --git a/Tests/Mocks/DefaultsServiceMock.swift b/Tests/Mocks/DefaultsServiceMock.swift new file mode 100644 index 0000000..d0a9916 --- /dev/null +++ b/Tests/Mocks/DefaultsServiceMock.swift @@ -0,0 +1,48 @@ +import Foundation + +@testable import Jottre + +final class DefaultsServiceMock: DefaultsServiceProtocol, @unchecked Sendable { + + private let lock = NSLock() + private var storage: [String: Any] = [:] + private var continuations: [String: [Any]] = [:] + + init(initialValues: [String: any LosslessStringConvertible & Sendable] = [:]) { + storage = initialValues + } + + func getValue(_ defaultsKey: DefaultsKey) -> T? { + lock.withLock { + storage[defaultsKey.description] as? T + } + } + + func set(_ defaultsKey: DefaultsKey, value: T?) { + let listeners: [AsyncStream.Continuation] = lock.withLock { + if let value { + storage[defaultsKey.description] = value + } else { + storage.removeValue(forKey: defaultsKey.description) + } + return (continuations[defaultsKey.description] ?? []) + .compactMap { $0 as? AsyncStream.Continuation } + } + for continuation in listeners { + continuation.yield(value) + } + } + + func getValueStream(_ defaultsKey: DefaultsKey) -> AsyncStream { + AsyncStream { [weak self] continuation in + guard let self else { + continuation.finish() + return + } + continuation.yield(self.getValue(defaultsKey)) + self.lock.withLock { + self.continuations[defaultsKey.description, default: []].append(continuation) + } + } + } +} diff --git a/Tests/Mocks/DeviceServiceMock.swift b/Tests/Mocks/DeviceServiceMock.swift new file mode 100644 index 0000000..ae25289 --- /dev/null +++ b/Tests/Mocks/DeviceServiceMock.swift @@ -0,0 +1,13 @@ +@testable import Jottre + +@MainActor +final class DeviceServiceMock: DeviceServiceProtocol { + + private let isIPadOSProvider: @MainActor () -> Bool + + init(isIPadOSProvider: @MainActor @escaping () -> Bool = { false }) { + self.isIPadOSProvider = isIPadOSProvider + } + + func isIPadOS() -> Bool { isIPadOSProvider() } +} diff --git a/Tests/Mocks/FileServiceMock.swift b/Tests/Mocks/FileServiceMock.swift new file mode 100644 index 0000000..7e64829 --- /dev/null +++ b/Tests/Mocks/FileServiceMock.swift @@ -0,0 +1,75 @@ +import Foundation + +@testable import Jottre + +final class FileServiceMock: FileServiceProtocol { + + private let isEnabledProvider: @Sendable () -> Bool + private let initializeDocumentsDirectoryProvider: @Sendable () async throws -> Void + private let documentsDirectoryProvider: @Sendable () async throws -> URL? + private let temporaryDirectoryProvider: @Sendable () -> URL + private let listContentsProvider: @Sendable (_ directory: URL, _ properties: [URLResourceKey]) throws -> [URL] + private let ubiquitousInfoProvider: @Sendable (_ url: URL) -> UbiquitousInfo? + private let startDownloadProvider: @Sendable (_ fileURL: URL) throws -> Void + private let directoryChangesProvider: @Sendable (_ directory: URL) -> AsyncStream + private let readFileProvider: @Sendable (_ fileURL: URL) throws -> Data + private let writeFileProvider: @Sendable (_ fileURL: URL, _ data: Data) throws -> Void + private let fileExistsProvider: @Sendable (_ fileURL: URL) -> Bool + private let removeFileProvider: @Sendable (_ fileURL: URL) throws -> Void + private let moveFileProvider: @Sendable (_ fileURL: URL, _ newFileURL: URL) throws -> Void + private let duplicateFileProvider: @Sendable (_ fileURL: URL) throws -> URL + + init( + isEnabledProvider: @Sendable @escaping () -> Bool = { true }, + initializeDocumentsDirectoryProvider: @Sendable @escaping () async throws -> Void = {}, + documentsDirectoryProvider: @Sendable @escaping () async throws -> URL? = { nil }, + temporaryDirectoryProvider: @Sendable @escaping () -> URL = { URL(fileURLWithPath: NSTemporaryDirectory()) }, + listContentsProvider: @Sendable @escaping (_ directory: URL, _ properties: [URLResourceKey]) throws -> [URL] = { + _, + _ in [] + }, + ubiquitousInfoProvider: @Sendable @escaping (_ url: URL) -> UbiquitousInfo? = { _ in nil }, + startDownloadProvider: @Sendable @escaping (_ fileURL: URL) throws -> Void = { _ in }, + directoryChangesProvider: @Sendable @escaping (_ directory: URL) -> AsyncStream = { _ in + AsyncStream { $0.finish() } + }, + readFileProvider: @Sendable @escaping (_ fileURL: URL) throws -> Data = { _ in Data() }, + writeFileProvider: @Sendable @escaping (_ fileURL: URL, _ data: Data) throws -> Void = { _, _ in }, + fileExistsProvider: @Sendable @escaping (_ fileURL: URL) -> Bool = { _ in false }, + removeFileProvider: @Sendable @escaping (_ fileURL: URL) throws -> Void = { _ in }, + moveFileProvider: @Sendable @escaping (_ fileURL: URL, _ newFileURL: URL) throws -> Void = { _, _ in }, + duplicateFileProvider: @Sendable @escaping (_ fileURL: URL) throws -> URL = { $0 } + ) { + self.isEnabledProvider = isEnabledProvider + self.initializeDocumentsDirectoryProvider = initializeDocumentsDirectoryProvider + self.documentsDirectoryProvider = documentsDirectoryProvider + self.temporaryDirectoryProvider = temporaryDirectoryProvider + self.listContentsProvider = listContentsProvider + self.ubiquitousInfoProvider = ubiquitousInfoProvider + self.startDownloadProvider = startDownloadProvider + self.directoryChangesProvider = directoryChangesProvider + self.readFileProvider = readFileProvider + self.writeFileProvider = writeFileProvider + self.fileExistsProvider = fileExistsProvider + self.removeFileProvider = removeFileProvider + self.moveFileProvider = moveFileProvider + self.duplicateFileProvider = duplicateFileProvider + } + + func isEnabled() -> Bool { isEnabledProvider() } + func initializeDocumentsDirectory() async throws { try await initializeDocumentsDirectoryProvider() } + func documentsDirectory() async throws -> URL? { try await documentsDirectoryProvider() } + func temporaryDirectory() -> URL { temporaryDirectoryProvider() } + func listContents(directory: URL, properties: [URLResourceKey]) throws -> [URL] { + try listContentsProvider(directory, properties) + } + func ubiquitousInfo(url: URL) -> UbiquitousInfo? { ubiquitousInfoProvider(url) } + func startDownload(fileURL: URL) throws { try startDownloadProvider(fileURL) } + func directoryChanges(directory: URL) -> AsyncStream { directoryChangesProvider(directory) } + func readFile(fileURL: URL) throws -> Data { try readFileProvider(fileURL) } + func writeFile(fileURL: URL, data: Data) throws { try writeFileProvider(fileURL, data) } + func fileExists(fileURL: URL) -> Bool { fileExistsProvider(fileURL) } + func removeFile(fileURL: URL) throws { try removeFileProvider(fileURL) } + func moveFile(fileURL: URL, newFileURL: URL) throws { try moveFileProvider(fileURL, newFileURL) } + func duplicateFile(fileURL: URL) throws -> URL { try duplicateFileProvider(fileURL) } +} diff --git a/Tests/Mocks/JotFileConflictServiceMock.swift b/Tests/Mocks/JotFileConflictServiceMock.swift new file mode 100644 index 0000000..59915e0 --- /dev/null +++ b/Tests/Mocks/JotFileConflictServiceMock.swift @@ -0,0 +1,38 @@ +@testable import Jottre + +final class JotFileConflictServiceMock: JotFileConflictServiceProtocol { + + private let getConfictingVersionsProvider: @Sendable (_ jotFileInfo: JotFile.Info) -> [JotFileVersion]? + private let resolveVersionConflictsProvider: + @Sendable (_ jotFileInfo: JotFile.Info, _ resolvedVersions: [JotFileVersion]) throws -> Void + private let copyVersionToTemporaryProvider: + @Sendable (_ jotFileInfo: JotFile.Info, _ jotFileVersion: JotFileVersion) throws -> JotFile.Info? + + init( + getConfictingVersionsProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) -> [JotFileVersion]? = { _ in + nil + }, + resolveVersionConflictsProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ resolvedVersions: [JotFileVersion]) throws -> Void = { + _, + _ in + }, + copyVersionToTemporaryProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ jotFileVersion: JotFileVersion) throws -> JotFile.Info? = + { _, _ in nil } + ) { + self.getConfictingVersionsProvider = getConfictingVersionsProvider + self.resolveVersionConflictsProvider = resolveVersionConflictsProvider + self.copyVersionToTemporaryProvider = copyVersionToTemporaryProvider + } + + func getConfictingVersions(jotFileInfo: JotFile.Info) -> [JotFileVersion]? { + getConfictingVersionsProvider(jotFileInfo) + } + func resolveVersionConflicts(jotFileInfo: JotFile.Info, resolvedVersions: [JotFileVersion]) throws { + try resolveVersionConflictsProvider(jotFileInfo, resolvedVersions) + } + func copyVersionToTemporary(jotFileInfo: JotFile.Info, jotFileVersion: JotFileVersion) throws -> JotFile.Info? { + try copyVersionToTemporaryProvider(jotFileInfo, jotFileVersion) + } +} diff --git a/Tests/Mocks/JotFilePreviewImageServiceMock.swift b/Tests/Mocks/JotFilePreviewImageServiceMock.swift new file mode 100644 index 0000000..8536eac --- /dev/null +++ b/Tests/Mocks/JotFilePreviewImageServiceMock.swift @@ -0,0 +1,33 @@ +import Foundation +import UIKit + +@testable import Jottre + +final class JotFilePreviewImageServiceMock: JotFilePreviewImageServiceProtocol { + + private let getPreviewImageDataProvider: + @Sendable ( + _ jotFileInfo: JotFile.Info, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async throws -> Data + + init( + getPreviewImageDataProvider: + @Sendable @escaping ( + _ jotFileInfo: JotFile.Info, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async throws -> Data = { _, _, _ in Data() } + ) { + self.getPreviewImageDataProvider = getPreviewImageDataProvider + } + + func getPreviewImageData( + jotFileInfo: JotFile.Info, + userInterfaceStyle: UIUserInterfaceStyle, + displayScale: CGFloat + ) async throws -> Data { + try await getPreviewImageDataProvider(jotFileInfo, userInterfaceStyle, displayScale) + } +} diff --git a/Tests/Mocks/JotFileServiceMock.swift b/Tests/Mocks/JotFileServiceMock.swift new file mode 100644 index 0000000..663013c --- /dev/null +++ b/Tests/Mocks/JotFileServiceMock.swift @@ -0,0 +1,66 @@ +import Foundation + +@testable import Jottre + +final class JotFileServiceMock: JotFileServiceProtocol { + + private let documentsDirectoryContentsProvider: @Sendable () -> AsyncThrowingStream<[JotFile.Info], Error> + private let readJotFileProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> JotFile + private let writeProvider: @Sendable (_ jotFile: JotFile) throws -> Void + private let duplicateProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> JotFile.Info + private let renameProvider: @Sendable (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info + private let removeProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> Void + private let moveProvider: + @Sendable (_ jotFileInfo: JotFile.Info, _ shouldBecomeUbiquitous: Bool) async throws -> Void + + init( + documentsDirectoryContentsProvider: @Sendable @escaping () -> AsyncThrowingStream<[JotFile.Info], Error> = { + AsyncThrowingStream { $0.finish() } + }, + readJotFileProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> JotFile = { info in + JotFile(info: info, jot: Jot.makeEmpty()) + }, + writeProvider: @Sendable @escaping (_ jotFile: JotFile) throws -> Void = { _ in }, + duplicateProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> JotFile.Info = { $0 }, + renameProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info = { + info, + _ in info + }, + removeProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> Void = { _ in }, + moveProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ shouldBecomeUbiquitous: Bool) async throws -> Void = { + _, + _ in + } + ) { + self.documentsDirectoryContentsProvider = documentsDirectoryContentsProvider + self.readJotFileProvider = readJotFileProvider + self.writeProvider = writeProvider + self.duplicateProvider = duplicateProvider + self.renameProvider = renameProvider + self.removeProvider = removeProvider + self.moveProvider = moveProvider + } + + func documentsDirectoryContents() -> AsyncThrowingStream<[JotFile.Info], Error> { + documentsDirectoryContentsProvider() + } + func readJotFile(jotFileInfo: JotFile.Info) throws -> JotFile { + try readJotFileProvider(jotFileInfo) + } + func write(jotFile: JotFile) throws { + try writeProvider(jotFile) + } + func duplicate(jotFileInfo: JotFile.Info) throws -> JotFile.Info { + try duplicateProvider(jotFileInfo) + } + func rename(jotFileInfo: JotFile.Info, newName: String) throws -> JotFile.Info { + try renameProvider(jotFileInfo, newName) + } + func remove(jotFileInfo: JotFile.Info) throws { + try removeProvider(jotFileInfo) + } + func move(jotFileInfo: JotFile.Info, shouldBecomeUbiquitous: Bool) async throws { + try await moveProvider(jotFileInfo, shouldBecomeUbiquitous) + } +} diff --git a/Tests/Navigation/EditJotURLTests.swift b/Tests/Navigation/EditJotURLTests.swift new file mode 100644 index 0000000..60c7916 --- /dev/null +++ b/Tests/Navigation/EditJotURLTests.swift @@ -0,0 +1,76 @@ +import XCTest + +@testable import Jottre + +final class EditJotURLTests: XCTestCase { + + func test_init_givenJotFileInfo_setsFileURLFromInfo() { + // Given + let fileURL = URL(staticString: "file:///tmp/note.jot") + let info = JotFile.Info( + url: fileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + + // When + let editJotURL = EditJotURL(jotFileInfo: info) + + // Then + XCTAssertEqual(editJotURL.fileURL, fileURL) + XCTAssertEqual(editJotURL.path, "/jots/edit") + } + + func test_initFromURL_givenMatchingPathAndQueryItem_succeeds() throws { + // Given + let url = URL(staticString: "scheme:///jots/edit?fileURL=file:///tmp/note.jot") + + // When + let editJotURL = try XCTUnwrap(EditJotURL(url: url)) + + // Then + XCTAssertEqual(editJotURL.fileURL, URL(staticString: "file:///tmp/note.jot")) + } + + func test_initFromURL_givenWrongPath_returnsNil() { + // Given + let url = URL(staticString: "scheme:///not/the/right/path?fileURL=file:///tmp/note.jot") + + // When + let editJotURL = EditJotURL(url: url) + + // Then + XCTAssertNil(editJotURL) + } + + func test_initFromURL_givenMissingFileURLQueryItem_returnsNil() { + // Given + let url = URL(staticString: "scheme:///jots/edit") + + // When + let editJotURL = EditJotURL(url: url) + + // Then + XCTAssertNil(editJotURL) + } + + func test_toURL_roundTripsFileURL() throws { + // Given + let fileURL = URL(staticString: "file:///tmp/note.jot") + let original = EditJotURL( + jotFileInfo: JotFile.Info( + url: fileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + ) + + // When + let roundTripped = try XCTUnwrap(EditJotURL(url: original.toURL())) + + // Then + XCTAssertEqual(roundTripped.fileURL, fileURL) + } +} diff --git a/Tests/Navigation/EnableICloudSupportURLTests.swift b/Tests/Navigation/EnableICloudSupportURLTests.swift new file mode 100644 index 0000000..a8067a0 --- /dev/null +++ b/Tests/Navigation/EnableICloudSupportURLTests.swift @@ -0,0 +1,42 @@ +import XCTest + +@testable import Jottre + +final class EnableICloudSupportURLTests: XCTestCase { + + func test_init_givenLocaleWithLanguageAndRegion_buildsLocalizedSupportPath() { + // Given + let locale = Locale(identifier: "en_US") + + // When + let url = EnableICloudSupportURL(locale: locale) + + // Then + XCTAssertEqual(url.scheme, "https") + XCTAssertEqual(url.host, "support.apple.com") + XCTAssertEqual(url.path, "/en-us/guide/icloud/mmfc0f1e2a/icloud") + } + + func test_init_givenLocaleWithoutRegion_buildsGenericSupportPath() { + // Given + let locale = Locale(identifier: "en") + + // When + let url = EnableICloudSupportURL(locale: locale) + + // Then + XCTAssertEqual(url.path, "/guide/icloud/mmfc0f1e2a/icloud") + } + + func test_toURL_producesAppleSupportURL() { + // Given + let url = EnableICloudSupportURL(locale: Locale(identifier: "de_DE")) + + // When + let resolved = url.toURL() + + // Then + XCTAssertEqual(resolved.scheme, "https") + XCTAssertEqual(resolved.host, "support.apple.com") + } +} diff --git a/Tests/Navigation/JotsPageURLTests.swift b/Tests/Navigation/JotsPageURLTests.swift new file mode 100644 index 0000000..6e7cc13 --- /dev/null +++ b/Tests/Navigation/JotsPageURLTests.swift @@ -0,0 +1,25 @@ +import XCTest + +@testable import Jottre + +final class JotsPageURLTests: XCTestCase { + + func test_path_isRoot() { + // Given / When + let url = JotsPageURL() + + // Then + XCTAssertEqual(url.path, "/") + } + + func test_toURL_producesURLWithRootPath() { + // Given + let url = JotsPageURL() + + // When + let result = url.toURL() + + // Then + XCTAssertEqual(result.path, "/") + } +} diff --git a/Tests/Navigation/JottreGithubURLTests.swift b/Tests/Navigation/JottreGithubURLTests.swift new file mode 100644 index 0000000..ddab2fc --- /dev/null +++ b/Tests/Navigation/JottreGithubURLTests.swift @@ -0,0 +1,24 @@ +import XCTest + +@testable import Jottre + +final class JottreGithubURLTests: XCTestCase { + + func test_components_pointToProjectGithubRepository() { + // Given / When + let url = JottreGithubURL() + + // Then + XCTAssertEqual(url.scheme, "https") + XCTAssertEqual(url.host, "github.com") + XCTAssertEqual(url.path, "/antonlorani/jottre") + } + + func test_toURL_producesAbsoluteURL() { + // When + let resolved = JottreGithubURL().toURL() + + // Then + XCTAssertEqual(resolved.absoluteString, "https://github.com/antonlorani/jottre") + } +} diff --git a/Tests/Navigation/RevealFileURLTests.swift b/Tests/Navigation/RevealFileURLTests.swift new file mode 100644 index 0000000..aae7450 --- /dev/null +++ b/Tests/Navigation/RevealFileURLTests.swift @@ -0,0 +1,41 @@ +import XCTest + +@testable import Jottre + +final class RevealFileURLTests: XCTestCase { + + func test_init_givenJotFileInfo_extractsPathFromInfoURL() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/dir/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + + // When + let revealFileURL = RevealFileURL(jotFileInfo: info) + + // Then + XCTAssertEqual(revealFileURL.scheme, "shareddocuments") + XCTAssertEqual(revealFileURL.host, "") + XCTAssertEqual(revealFileURL.path, "/tmp/dir/note.jot") + } + + func test_toURL_producesSharedDocumentsURL() throws { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/dir/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + + // When + let result = RevealFileURL(jotFileInfo: info).toURL() + + // Then + XCTAssertEqual(result.scheme, "shareddocuments") + XCTAssertEqual(result.path, "/tmp/dir/note.jot") + } +} diff --git a/Tests/PageViewController/PageCellSizingStrategyTests.swift b/Tests/PageViewController/PageCellSizingStrategyTests.swift new file mode 100644 index 0000000..bfc22fa --- /dev/null +++ b/Tests/PageViewController/PageCellSizingStrategyTests.swift @@ -0,0 +1,65 @@ +import XCTest + +@testable import Jottre + +final class PageCellSizingStrategyTests: XCTestCase { + + func test_columnSpacing_givenFullWidth_isZero() { + // Given + let strategy = PageCellSizingStrategy.fullWidth() + + // Then + XCTAssertEqual(strategy.columnSpacing, .zero) + } + + func test_columnSpacing_givenEqualSplit_returnsConfiguredColumnSpacing() { + // Given + let strategy = PageCellSizingStrategy.equalSplit( + perRow: 2, + itemHeight: 100, + columnSpacing: 12, + rowSpacing: 8 + ) + + // Then + XCTAssertEqual(strategy.columnSpacing, 12) + } + + func test_rowSpacing_givenEqualSplit_returnsConfiguredRowSpacing() { + // Given + let strategy = PageCellSizingStrategy.equalSplit( + perRow: 2, + itemHeight: 100, + columnSpacing: 12, + rowSpacing: 8 + ) + + // Then + XCTAssertEqual(strategy.rowSpacing, 8) + } + + func test_columnAndRowSpacing_givenAdaptiveGrid_returnsConfiguredSpacings() { + // Given + let strategy = PageCellSizingStrategy.adaptiveGrid( + minColumns: 2, + maxColumns: 8, + minItemWidth: 100, + maxItemWidth: 200, + columnSpacing: 16, + rowSpacing: 24, + aspectRatio: CGSize(width: 1, height: 1) + ) + + // Then + XCTAssertEqual(strategy.columnSpacing, 16) + XCTAssertEqual(strategy.rowSpacing, 24) + } + + func test_rowSpacing_givenFullWidthWithDefaultRowSpacing_returnsDefault() { + // Given + let strategy = PageCellSizingStrategy.fullWidth(estimatedHeight: 120, rowSpacing: 7) + + // Then + XCTAssertEqual(strategy.rowSpacing, 7) + } +} diff --git a/Tests/PageViewController/PageHeaderCellViewModelTests.swift b/Tests/PageViewController/PageHeaderCellViewModelTests.swift new file mode 100644 index 0000000..90e0e82 --- /dev/null +++ b/Tests/PageViewController/PageHeaderCellViewModelTests.swift @@ -0,0 +1,19 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class PageHeaderCellViewModelTests: XCTestCase { + + func test_init_storesHeadlineAndSubheadline() { + // When + let viewModel = PageHeaderCellViewModel( + headline: "Headline", + subheadline: "Subheadline" + ) + + // Then + XCTAssertEqual(viewModel.headline, "Headline") + XCTAssertEqual(viewModel.subheadline, "Subheadline") + } +} diff --git a/Tests/SettingsPage/SettingsRepositoryTests.swift b/Tests/SettingsPage/SettingsRepositoryTests.swift new file mode 100644 index 0000000..30292c5 --- /dev/null +++ b/Tests/SettingsPage/SettingsRepositoryTests.swift @@ -0,0 +1,115 @@ +import UIKit +import XCTest + +@testable import Jottre + +final class SettingsRepositoryTests: XCTestCase { + + func test_shouldShowEnableICloudButton_givenUbiquitousServiceDisabled_returnsTrue() { + // Given + let repository = SettingsRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { false }), + bundleService: BundleServiceMock(), + defaultsService: DefaultsServiceMock() + ) + + // Then + XCTAssertTrue(repository.shouldShowEnableICloudButton()) + } + + func test_shouldShowEnableICloudButton_givenUbiquitousServiceEnabled_returnsFalse() { + // Given + let repository = SettingsRepository( + ubiquitousFileService: FileServiceMock(isEnabledProvider: { true }), + bundleService: BundleServiceMock(), + defaultsService: DefaultsServiceMock() + ) + + // Then + XCTAssertFalse(repository.shouldShowEnableICloudButton()) + } + + func test_appVersion_givenBundleProvidesValue_returnsValue() { + // Given + let repository = SettingsRepository( + ubiquitousFileService: FileServiceMock(), + bundleService: BundleServiceMock(shortVersionStringProvider: { "1.2.3" }), + defaultsService: DefaultsServiceMock() + ) + + // Then + XCTAssertEqual(repository.appVersion(), "1.2.3") + } + + func test_appVersion_givenBundleReturnsNil_returnsDash() { + // Given + let repository = SettingsRepository( + ubiquitousFileService: FileServiceMock(), + bundleService: BundleServiceMock(shortVersionStringProvider: { nil }), + defaultsService: DefaultsServiceMock() + ) + + // Then + XCTAssertEqual(repository.appVersion(), "-") + } + + func test_userInterfaceStyle_givenStoredRawValue_emitsMatchingStyle() async throws { + // Given + let defaultsServiceMock = DefaultsServiceMock( + initialValues: [DefaultsKey.userInterfaceStyle.description: UIUserInterfaceStyle.dark.rawValue] + ) + let repository = SettingsRepository( + ubiquitousFileService: FileServiceMock(), + bundleService: BundleServiceMock(), + defaultsService: defaultsServiceMock + ) + + // When + var iterator = repository.userInterfaceStyle().makeAsyncIterator() + let first = try await XCTUnwrapAsync(await iterator.next()) + + // Then + XCTAssertEqual(first, .dark) + } + + func test_userInterfaceStyle_givenNoStoredValue_emitsUnspecified() async throws { + // Given + let repository = SettingsRepository( + ubiquitousFileService: FileServiceMock(), + bundleService: BundleServiceMock(), + defaultsService: DefaultsServiceMock() + ) + + // When + var iterator = repository.userInterfaceStyle().makeAsyncIterator() + let first = try await XCTUnwrapAsync(await iterator.next()) + + // Then + XCTAssertEqual(first, .unspecified) + } + + func test_updateUserInterfaceStyle_persistsRawValueInDefaults() { + // Given + let defaultsServiceMock = DefaultsServiceMock() + let repository = SettingsRepository( + ubiquitousFileService: FileServiceMock(), + bundleService: BundleServiceMock(), + defaultsService: defaultsServiceMock + ) + + // When + repository.updateUserInterfaceStyle(.light) + + // Then + XCTAssertEqual(defaultsServiceMock.getValue(.userInterfaceStyle), UIUserInterfaceStyle.light.rawValue) + } +} + +private func XCTUnwrapAsync( + _ expression: @autoclosure () async throws -> T?, + file: StaticString = #filePath, + line: UInt = #line +) async throws -> T { + let value = try await expression() + return try XCTUnwrap(value, file: file, line: line) +} diff --git a/Tests/Utilities/Array+safeIndexTests.swift b/Tests/Utilities/Array+safeIndexTests.swift new file mode 100644 index 0000000..c9b7f15 --- /dev/null +++ b/Tests/Utilities/Array+safeIndexTests.swift @@ -0,0 +1,39 @@ +import XCTest + +@testable import Jottre + +final class ArraySafeIndexTests: XCTestCase { + + func test_safeSubscript_givenIndexInBounds_returnsElement() { + // Given + let array = [10, 20, 30] + + // When + let element = array[safe: 1] + + // Then + XCTAssertEqual(element, 20) + } + + func test_safeSubscript_givenIndexOutOfBounds_returnsNil() { + // Given + let array = [10, 20, 30] + + // When + let element = array[safe: 5] + + // Then + XCTAssertNil(element) + } + + func test_safeSubscript_givenEmptyArray_returnsNil() { + // Given + let array: [Int] = [] + + // When + let element = array[safe: 0] + + // Then + XCTAssertNil(element) + } +} diff --git a/Tests/Utilities/AsyncSequenceDebounceTests.swift b/Tests/Utilities/AsyncSequenceDebounceTests.swift new file mode 100644 index 0000000..20e1f53 --- /dev/null +++ b/Tests/Utilities/AsyncSequenceDebounceTests.swift @@ -0,0 +1,51 @@ +import XCTest + +@testable import Jottre + +final class AsyncSequenceDebounceTests: XCTestCase { + + func test_debounce_givenSingleValue_yieldsValueAfterInterval() async throws { + // Given + let stream = AsyncStream { continuation in + continuation.yield(1) + continuation.finish() + } + + // When + var iterator = stream.debounce(for: 0.05).makeAsyncIterator() + let first = try await XCTUnwrapAsync(await iterator.next()) + let second = await iterator.next() + + // Then + XCTAssertEqual(first, 1) + XCTAssertNil(second) + } + + func test_debounce_givenBurstOfValues_yieldsOnlyLastValue() async throws { + // Given + let stream = AsyncStream { continuation in + continuation.yield(1) + continuation.yield(2) + continuation.yield(3) + continuation.finish() + } + + // When + var values: [Int] = [] + for await value in stream.debounce(for: 0.05) { + values.append(value) + } + + // Then + XCTAssertEqual(values, [3]) + } +} + +private func XCTUnwrapAsync( + _ expression: @autoclosure () async throws -> T?, + file: StaticString = #filePath, + line: UInt = #line +) async throws -> T { + let value = try await expression() + return try XCTUnwrap(value, file: file, line: line) +} diff --git a/Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift b/Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift new file mode 100644 index 0000000..6683398 --- /dev/null +++ b/Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift @@ -0,0 +1,64 @@ +import XCTest + +@testable import Jottre + +final class AsyncSequenceToAsyncThrowingStreamTests: XCTestCase { + + func test_toAsyncThrowingStream_givenFiniteSequence_yieldsAllElementsThenFinishes() async throws { + // Given + let source = AsyncStream { continuation in + continuation.yield(1) + continuation.yield(2) + continuation.yield(3) + continuation.finish() + } + + // When + var collected: [Int] = [] + for try await value in source.toAsyncThrowingStream() { + collected.append(value) + } + + // Then + XCTAssertEqual(collected, [1, 2, 3]) + } + + func test_toAsyncStream_givenFiniteSequence_yieldsAllElementsThenFinishes() async { + // Given + let source = AsyncStream { continuation in + continuation.yield(10) + continuation.yield(20) + continuation.finish() + } + + // When + var collected: [Int] = [] + for await value in source.toAsyncStream() { + collected.append(value) + } + + // Then + XCTAssertEqual(collected, [10, 20]) + } + + func test_toAsyncThrowingStream_givenThrowingUpstream_propagatesError() async { + // Given + struct DummyError: Error, Equatable {} + let source = AsyncThrowingStream { continuation in + continuation.yield(1) + continuation.finish(throwing: DummyError()) + } + + // When / Then + do { + for try await _ in source.toAsyncThrowingStream() { + /* no-op */ + } + XCTFail("Expected the upstream error to propagate.") + } catch is DummyError { + // Expected + } catch { + XCTFail("Unexpected error: \(error)") + } + } +} diff --git a/project.yml b/project.yml index fe7bacd..3424d1b 100644 --- a/project.yml +++ b/project.yml @@ -122,6 +122,21 @@ targets: codeSign: true packages: [] + JottreTests: + type: bundle.unit-test + platform: iOS + deploymentTarget: "15.0" + sources: + - Tests + dependencies: + - target: Jottre + settings: + base: + PRODUCT_BUNDLE_IDENTIFIER: com.antonlorani.jottre.JottreTests + SWIFT_VERSION: "6.0" + SWIFT_STRICT_CONCURRENCY: complete + GENERATE_INFOPLIST_FILE: YES + AppKitPlugin: type: bundle platform: macOS @@ -145,3 +160,47 @@ targets: CODE_SIGN_IDENTITY: "-" MACH_O_TYPE: mh_bundle ENABLE_HARDENED_RUNTIME: YES + +schemes: + Jottre: + build: + targets: + Jottre: all + AppKitPlugin: all + run: + config: Debug + test: + config: Debug + targets: + - name: JottreTests + archive: + config: Release + profile: + config: Release + analyze: + config: Debug + + JottreTests: + build: + targets: + JottreTests: all + Jottre: all + test: + config: Debug + targets: + - name: JottreTests + analyze: + config: Debug + + AppKitPlugin: + build: + targets: + AppKitPlugin: all + run: + config: Debug + archive: + config: Release + profile: + config: Release + analyze: + config: Debug From 83e85caac9459f81f6ca93a59fdabada73fc00c9 Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Wed, 6 May 2026 22:43:00 +0200 Subject: [PATCH 2/9] Ensure Jottre is selected as executable target (#124) --- project.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/project.yml b/project.yml index 3424d1b..81a20b6 100644 --- a/project.yml +++ b/project.yml @@ -169,6 +169,7 @@ schemes: AppKitPlugin: all run: config: Debug + executable: Jottre test: config: Debug targets: From c77bbf42ab0592dc0b2126e11d835d99e406ae87 Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Thu, 7 May 2026 00:04:29 +0200 Subject: [PATCH 3/9] Adds additional tests (#124) --- .../CloudImageCellViewModelTests.swift | 19 ++ .../CloudMigrationJotCellViewModelTests.swift | 118 +++++++++++++ Tests/FileService/LocalFileServiceTests.swift | 152 ++++++++++++++++ ...rviceDocumentsDirectoryContentsTests.swift | 164 +++++++++++++++++ Tests/Jot/JotFileServiceTests.swift | 73 ++++++++ .../JotConflictCellViewModelTests.swift | 123 +++++++++++++ .../JotConflictRepositoryTests.swift | 166 ++++++++++++++++++ .../JotFileConflictServiceTests.swift | 130 ++++++++++++++ ...achedJotFilePreviewImageServiceTests.swift | 74 ++++++++ Tests/JotsPage/JotCellViewModelTests.swift | 138 +++++++++++++++ Tests/JotsPage/ShareJotRepositoryTests.swift | 114 ++++++++++++ .../Mocks/CloudMigrationRepositoryMock.swift | 69 ++++++++ Tests/Mocks/FileConflictServiceMock.swift | 34 ++++ Tests/Mocks/JotConflictRepositoryMock.swift | 51 ++++++ Tests/Mocks/JotsRepositoryMock.swift | 79 +++++++++ ...IOS18SymbolBarButtonItemFactoryTests.swift | 36 ++++ .../IOS18TextBarButtonItemFactoryTests.swift | 21 +++ .../SettingsDropdownCellViewModelTests.swift | 50 ++++++ ...ttingsExternalLinkCellViewModelTests.swift | 51 ++++++ .../SettingsInfoCellViewModelTests.swift | 32 ++++ .../SettingsToggleCellViewModelTests.swift | 32 ++++ .../NSLayoutConstraintWithPriorityTests.swift | 32 ++++ .../UIColorAdaptiveBlackWhiteTests.swift | 29 +++ .../Utilities/UIFontPreferredFontTests.swift | 26 +++ ...aitCollectionHasRenderingChangeTests.swift | 71 ++++++++ 25 files changed, 1884 insertions(+) create mode 100644 Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift create mode 100644 Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift create mode 100644 Tests/FileService/LocalFileServiceTests.swift create mode 100644 Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift create mode 100644 Tests/JotConflictPage/JotConflictCellViewModelTests.swift create mode 100644 Tests/JotConflictPage/JotConflictRepositoryTests.swift create mode 100644 Tests/JotConflictPage/JotFileConflictServiceTests.swift create mode 100644 Tests/JotsPage/JotCellViewModelTests.swift create mode 100644 Tests/JotsPage/ShareJotRepositoryTests.swift create mode 100644 Tests/Mocks/CloudMigrationRepositoryMock.swift create mode 100644 Tests/Mocks/FileConflictServiceMock.swift create mode 100644 Tests/Mocks/JotConflictRepositoryMock.swift create mode 100644 Tests/Mocks/JotsRepositoryMock.swift create mode 100644 Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift create mode 100644 Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift create mode 100644 Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift create mode 100644 Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift create mode 100644 Tests/SettingsPage/SettingsInfoCellViewModelTests.swift create mode 100644 Tests/SettingsPage/SettingsToggleCellViewModelTests.swift create mode 100644 Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift create mode 100644 Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift create mode 100644 Tests/Utilities/UIFontPreferredFontTests.swift create mode 100644 Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift diff --git a/Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift b/Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift new file mode 100644 index 0000000..f55ada8 --- /dev/null +++ b/Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift @@ -0,0 +1,19 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class CloudImageCellViewModelTests: XCTestCase { + + func test_handleAction_givenTap_doesNothing() { + // Given + let viewModel = CloudImageCellViewModel() + + // When + viewModel.handle(action: .tap) + + // Then + // No-op cell — the only assertion is that handling does not throw. + XCTAssertNotNil(viewModel) + } +} diff --git a/Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift b/Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift new file mode 100644 index 0000000..a677173 --- /dev/null +++ b/Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift @@ -0,0 +1,118 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class CloudMigrationJotCellViewModelTests: XCTestCase { + + func test_init_storesNameInfoTextAndCloudFlagsFromBusinessModel() { + // Given + let date = Date(timeIntervalSince1970: 1_700_000_000) + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: date, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + let businessModel = CloudMigrationJotBusinessModel(jotFileInfo: jotFileInfo) + let expectedInfoText = DateFormatter.localizedString( + from: date, + dateStyle: .long, + timeStyle: .short + ) + + // When + let viewModel = CloudMigrationJotCellViewModel( + cloudMigrationJot: businessModel, + repository: CloudMigrationRepositoryMock(), + onTap: {} + ) + + // Then + XCTAssertEqual(viewModel.name, "note") + XCTAssertEqual(viewModel.infoText, expectedInfoText) + XCTAssertTrue(viewModel.isCloudCheckboxOn) + XCTAssertFalse(viewModel.isDownloading) + } + + func test_init_givenLocalJotFile_setsCloudCheckboxOff() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + + // When + let viewModel = CloudMigrationJotCellViewModel( + cloudMigrationJot: CloudMigrationJotBusinessModel(jotFileInfo: jotFileInfo), + repository: CloudMigrationRepositoryMock(), + onTap: {} + ) + + // Then + XCTAssertFalse(viewModel.isCloudCheckboxOn) + XCTAssertEqual(viewModel.infoText, "") + } + + func test_handleAction_givenTap_invokesOnTap() async { + // Given + let onTapExpectation = XCTestExpectation(description: "onTap is called.") + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let viewModel = CloudMigrationJotCellViewModel( + cloudMigrationJot: CloudMigrationJotBusinessModel(jotFileInfo: jotFileInfo), + repository: CloudMigrationRepositoryMock(), + onTap: { onTapExpectation.fulfill() } + ) + + // When + viewModel.handle(action: .tap) + + // Then + await fulfillment(of: [onTapExpectation], timeout: 0.2) + } + + func test_getPreviewImage_forwardsJotFileInfoToRepository() async throws { + // Given + let getPreviewImageExpectation = XCTestExpectation( + description: "CloudMigrationRepositoryMock.getPreviewImageProvider is called." + ) + let expectedImage = UIImage() + let expectedFileURL = URL(staticString: "file:///tmp/note.jot") + let jotFileInfo = JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let repositoryMock = CloudMigrationRepositoryMock( + getPreviewImageProvider: { receivedInfo, receivedStyle, receivedScale in + // Then + XCTAssertEqual(receivedInfo.url, expectedFileURL) + XCTAssertEqual(receivedStyle, .light) + XCTAssertEqual(receivedScale, 2.0) + getPreviewImageExpectation.fulfill() + return expectedImage + } + ) + let viewModel = CloudMigrationJotCellViewModel( + cloudMigrationJot: CloudMigrationJotBusinessModel(jotFileInfo: jotFileInfo), + repository: repositoryMock, + onTap: {} + ) + + // When + let image = await viewModel.getPreviewImage(userInterfaceStyle: .light, displayScale: 2.0) + + // Then + XCTAssertIdentical(image, expectedImage) + await fulfillment(of: [getPreviewImageExpectation], timeout: 0.2) + } +} diff --git a/Tests/FileService/LocalFileServiceTests.swift b/Tests/FileService/LocalFileServiceTests.swift new file mode 100644 index 0000000..b63132d --- /dev/null +++ b/Tests/FileService/LocalFileServiceTests.swift @@ -0,0 +1,152 @@ +import Foundation +import XCTest + +@testable import Jottre + +final class LocalFileServiceTests: XCTestCase { + + private var rootDirectory: URL! + private var fileService: LocalFileService! + + override func setUpWithError() throws { + try super.setUpWithError() + rootDirectory = FileManager.default.temporaryDirectory + .appendingPathComponent(UUID().uuidString, isDirectory: true) + try FileManager.default.createDirectory(at: rootDirectory, withIntermediateDirectories: true) + fileService = LocalFileService(fileManager: FileManager.default) + } + + override func tearDownWithError() throws { + try? FileManager.default.removeItem(at: rootDirectory) + rootDirectory = nil + fileService = nil + try super.tearDownWithError() + } + + func test_isEnabled_alwaysReturnsTrue() { + // Then + XCTAssertTrue(fileService.isEnabled()) + } + + func test_temporaryDirectory_returnsFileManagerTemporaryDirectory() { + // When + let url = fileService.temporaryDirectory() + + // Then + XCTAssertEqual(url, FileManager.default.temporaryDirectory) + } + + func test_writeFileThenReadFile_roundTripsBytes() throws { + // Given + let fileURL = rootDirectory.appendingPathComponent("note.jot") + let payload = Data("Hello".utf8) + + // When + try fileService.writeFile(fileURL: fileURL, data: payload) + let readBack = try fileService.readFile(fileURL: fileURL) + + // Then + XCTAssertEqual(readBack, payload) + } + + func test_fileExists_givenWrittenFile_returnsTrue() throws { + // Given + let fileURL = rootDirectory.appendingPathComponent("note.jot") + try Data().write(to: fileURL) + + // Then + XCTAssertTrue(fileService.fileExists(fileURL: fileURL)) + } + + func test_fileExists_givenMissingFile_returnsFalse() { + // Given + let fileURL = rootDirectory.appendingPathComponent("missing.jot") + + // Then + XCTAssertFalse(fileService.fileExists(fileURL: fileURL)) + } + + func test_listContents_givenMixOfFiles_returnsAllURLs() throws { + // Given + let fileURL1 = rootDirectory.appendingPathComponent("a.jot") + let fileURL2 = rootDirectory.appendingPathComponent("b.txt") + try Data().write(to: fileURL1) + try Data().write(to: fileURL2) + + // When + let urls = try fileService.listContents(directory: rootDirectory, properties: []) + + // Then + let names = Set(urls.map(\.lastPathComponent)) + XCTAssertEqual(names, ["a.jot", "b.txt"]) + } + + func test_moveFile_movesFileToDestinationAndDeletesOriginal() throws { + // Given + let originalURL = rootDirectory.appendingPathComponent("original.jot") + let destinationURL = rootDirectory.appendingPathComponent("destination.jot") + try Data("payload".utf8).write(to: originalURL) + + // When + try fileService.moveFile(fileURL: originalURL, newFileURL: destinationURL) + + // Then + XCTAssertFalse(FileManager.default.fileExists(atPath: originalURL.path)) + XCTAssertTrue(FileManager.default.fileExists(atPath: destinationURL.path)) + XCTAssertEqual(try Data(contentsOf: destinationURL), Data("payload".utf8)) + } + + func test_removeFile_deletesFile() throws { + // Given + let fileURL = rootDirectory.appendingPathComponent("note.jot") + try Data().write(to: fileURL) + + // When + try fileService.removeFile(fileURL: fileURL) + + // Then + XCTAssertFalse(FileManager.default.fileExists(atPath: fileURL.path)) + } + + func test_duplicateFile_givenNoExistingDuplicate_writesPlainNamedCopy() throws { + // Given + let originalURL = rootDirectory.appendingPathComponent("note.jot") + try Data("payload".utf8).write(to: originalURL) + + // When + let duplicatedURL = try fileService.duplicateFile(fileURL: originalURL) + + // Then + XCTAssertEqual(duplicatedURL.pathExtension, "jot") + XCTAssertNotEqual(duplicatedURL, originalURL) + XCTAssertTrue(FileManager.default.fileExists(atPath: duplicatedURL.path)) + XCTAssertEqual(try Data(contentsOf: duplicatedURL), Data("payload".utf8)) + } + + func test_duplicateFile_givenExistingDuplicate_writesIncrementedNamedCopy() throws { + // Given + let originalURL = rootDirectory.appendingPathComponent("note.jot") + try Data("payload".utf8).write(to: originalURL) + + // When + let firstDuplicate = try fileService.duplicateFile(fileURL: originalURL) + let secondDuplicate = try fileService.duplicateFile(fileURL: originalURL) + + // Then + XCTAssertNotEqual(firstDuplicate, secondDuplicate) + XCTAssertTrue(FileManager.default.fileExists(atPath: firstDuplicate.path)) + XCTAssertTrue(FileManager.default.fileExists(atPath: secondDuplicate.path)) + } + + func test_directoryChanges_emitsInitialEventOnSubscribe() async throws { + // Given + let stream = fileService.directoryChanges(directory: rootDirectory) + var iterator = stream.makeAsyncIterator() + + // When + let first = await iterator.next() + + // Then + XCTAssertNotNil(first) + } +} diff --git a/Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift b/Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift new file mode 100644 index 0000000..947fad2 --- /dev/null +++ b/Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift @@ -0,0 +1,164 @@ +import Foundation +import XCTest + +@testable import Jottre + +final class JotFileServiceDocumentsDirectoryContentsTests: XCTestCase { + + private var localDocumentsDirectory: URL! + private var ubiquitousDocumentsDirectory: URL! + + override func setUpWithError() throws { + try super.setUpWithError() + localDocumentsDirectory = FileManager.default.temporaryDirectory + .appendingPathComponent(UUID().uuidString, isDirectory: true) + ubiquitousDocumentsDirectory = FileManager.default.temporaryDirectory + .appendingPathComponent(UUID().uuidString, isDirectory: true) + try FileManager.default.createDirectory( + at: localDocumentsDirectory, + withIntermediateDirectories: true + ) + try FileManager.default.createDirectory( + at: ubiquitousDocumentsDirectory, + withIntermediateDirectories: true + ) + } + + override func tearDownWithError() throws { + try? FileManager.default.removeItem(at: localDocumentsDirectory) + try? FileManager.default.removeItem(at: ubiquitousDocumentsDirectory) + localDocumentsDirectory = nil + ubiquitousDocumentsDirectory = nil + try super.tearDownWithError() + } + + func test_documentsDirectoryContents_givenLocalAndUbiquitousJotFiles_yieldsCombinedContents() async throws { + // Given + let localFileURL = localDocumentsDirectory.appendingPathComponent("local.jot") + let ubiquitousFileURL = ubiquitousDocumentsDirectory.appendingPathComponent("cloud.jot") + try Data().write(to: localFileURL) + try Data().write(to: ubiquitousFileURL) + + let jotFileService = makeJotFileService() + + // When + var iterator = jotFileService.documentsDirectoryContents().makeAsyncIterator() + let infos = try await XCTUnwrapAsync(try await iterator.next()) + + // Then + let names = Set(infos.map(\.name)) + XCTAssertEqual(names, ["local", "cloud"]) + let cloudInfo = try XCTUnwrap(infos.first(where: { $0.name == "cloud" })) + XCTAssertNotNil(cloudInfo.ubiquitousInfo) + let localInfo = try XCTUnwrap(infos.first(where: { $0.name == "local" })) + XCTAssertNil(localInfo.ubiquitousInfo) + } + + func test_documentsDirectoryContents_givenNonJotFileInDirectory_filtersItOut() async throws { + // Given + let jotFileURL = localDocumentsDirectory.appendingPathComponent("real.jot") + let textFileURL = localDocumentsDirectory.appendingPathComponent("ignored.txt") + try Data().write(to: jotFileURL) + try Data().write(to: textFileURL) + + let jotFileService = makeJotFileService(includeUbiquitous: false) + + // When + var iterator = jotFileService.documentsDirectoryContents().makeAsyncIterator() + let infos = try await XCTUnwrapAsync(try await iterator.next()) + + // Then + XCTAssertEqual(infos.map(\.name), ["real"]) + } + + func test_documentsDirectoryContents_givenLocalDirectoryUnavailable_yieldsOnlyUbiquitousContents() async throws { + // Given + let ubiquitousFileURL = ubiquitousDocumentsDirectory.appendingPathComponent("cloud.jot") + try Data().write(to: ubiquitousFileURL) + + let localFileServiceMock = FileServiceMock( + documentsDirectoryProvider: { nil }, + listContentsProvider: { _, _ in [] } + ) + let ubiquitousFileServiceMock = FileServiceMock( + documentsDirectoryProvider: { [ubiquitousDocumentsDirectory] in ubiquitousDocumentsDirectory }, + listContentsProvider: { directory, _ in + try FileManager.default.contentsOfDirectory( + at: directory, + includingPropertiesForKeys: nil + ) + }, + directoryChangesProvider: { _ in + AsyncStream { continuation in + continuation.yield(()) + continuation.finish() + } + } + ) + let jotFileService = JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + var iterator = jotFileService.documentsDirectoryContents().makeAsyncIterator() + let infos = try await XCTUnwrapAsync(try await iterator.next()) + + // Then + XCTAssertEqual(infos.map(\.name), ["cloud"]) + } + + private func makeJotFileService(includeUbiquitous: Bool = true) -> JotFileService { + let localFileServiceMock = FileServiceMock( + documentsDirectoryProvider: { [localDocumentsDirectory] in localDocumentsDirectory }, + listContentsProvider: { directory, _ in + try FileManager.default.contentsOfDirectory( + at: directory, + includingPropertiesForKeys: nil + ) + }, + directoryChangesProvider: { _ in + AsyncStream { continuation in + continuation.yield(()) + continuation.finish() + } + } + ) + let ubiquitousFileServiceMock: FileServiceMock + if includeUbiquitous { + ubiquitousFileServiceMock = FileServiceMock( + documentsDirectoryProvider: { [ubiquitousDocumentsDirectory] in ubiquitousDocumentsDirectory }, + listContentsProvider: { directory, _ in + try FileManager.default.contentsOfDirectory( + at: directory, + includingPropertiesForKeys: nil + ) + }, + directoryChangesProvider: { _ in + AsyncStream { continuation in + continuation.yield(()) + continuation.finish() + } + } + ) + } else { + ubiquitousFileServiceMock = FileServiceMock( + documentsDirectoryProvider: { nil }, + listContentsProvider: { _, _ in [] } + ) + } + return JotFileService( + localFileService: localFileServiceMock, + ubiquitousFileService: ubiquitousFileServiceMock + ) + } +} + +private func XCTUnwrapAsync( + _ expression: @autoclosure () async throws -> T?, + file: StaticString = #filePath, + line: UInt = #line +) async throws -> T { + let value = try await expression() + return try XCTUnwrap(value, file: file, line: line) +} diff --git a/Tests/Jot/JotFileServiceTests.swift b/Tests/Jot/JotFileServiceTests.swift index 608bfc6..89aec90 100644 --- a/Tests/Jot/JotFileServiceTests.swift +++ b/Tests/Jot/JotFileServiceTests.swift @@ -329,6 +329,79 @@ final class JotFileServiceTests: XCTestCase { await fulfillment(of: [removeFileProviderExpectation], timeout: 0.2) } + func test_rename_givenUbiquitousJotFileInfo_movesViaUbiquitousFileService() async throws { + // Given + let moveFileProviderExpectation = XCTestExpectation(description: "Ubiquitous moveFileProvider is called.") + let originalFileURL = URL(staticString: "file:///cloud/old.jot") + let expectedNewFileURL = URL(staticString: "file:///cloud/new.jot") + let ubiquitousFileServiceMock = FileServiceMock( + moveFileProvider: { receivedFileURL, receivedNewFileURL in + // Then + XCTAssertEqual(receivedFileURL, originalFileURL) + XCTAssertEqual(receivedNewFileURL, expectedNewFileURL) + moveFileProviderExpectation.fulfill() + } + ) + let jotFileService = JotFileService( + localFileService: FileServiceMock(), + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + let renamed = try jotFileService.rename( + jotFileInfo: JotFile.Info( + url: originalFileURL, + name: "old", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ), + newName: "new" + ) + + // Then + XCTAssertEqual(renamed.url, expectedNewFileURL) + XCTAssertEqual(renamed.name, "new") + await fulfillment(of: [moveFileProviderExpectation], timeout: 0.2) + } + + func test_duplicate_givenUbiquitousJotFileInfo_returnsDuplicatedInfoFromUbiquitousFileService() async throws { + // Given + let duplicateFileProviderExpectation = XCTestExpectation( + description: "Ubiquitous duplicateFileProvider is called." + ) + let originalFileURL = URL(staticString: "file:///cloud/note.jot") + let duplicatedFileURL = URL(staticString: "file:///cloud/note-1.jot") + let originalUbiquitousInfo = UbiquitousInfo(downloadStatus: .current, isDownloading: false) + let ubiquitousFileServiceMock = FileServiceMock( + duplicateFileProvider: { receivedFileURL in + // Then + XCTAssertEqual(receivedFileURL, originalFileURL) + duplicateFileProviderExpectation.fulfill() + return duplicatedFileURL + } + ) + let jotFileService = JotFileService( + localFileService: FileServiceMock(), + ubiquitousFileService: ubiquitousFileServiceMock + ) + + // When + let duplicated = try jotFileService.duplicate( + jotFileInfo: JotFile.Info( + url: originalFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: originalUbiquitousInfo + ) + ) + + // Then + XCTAssertEqual(duplicated.url, duplicatedFileURL) + XCTAssertEqual(duplicated.name, "note-1") + XCTAssertEqual(duplicated.ubiquitousInfo, originalUbiquitousInfo) + await fulfillment(of: [duplicateFileProviderExpectation], timeout: 0.2) + } + func test_move_givenDocumentsDirectoryUnresolved_throwsCouldNotResolveFailure() async { // Given let localFileServiceMock = FileServiceMock( diff --git a/Tests/JotConflictPage/JotConflictCellViewModelTests.swift b/Tests/JotConflictPage/JotConflictCellViewModelTests.swift new file mode 100644 index 0000000..8b2ac91 --- /dev/null +++ b/Tests/JotConflictPage/JotConflictCellViewModelTests.swift @@ -0,0 +1,123 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class JotConflictCellViewModelTests: XCTestCase { + + func test_init_storesNameAndInfoTextFromBusinessModel() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let businessModel = JotConflictBusinessModel( + name: "note", + jotFileInfo: jotFileInfo, + jotFileVersion: JotFileVersion(localizedNameOfSavingComputer: "Mac", info: jotFileInfo) + ) + + // When + let viewModel = JotConflictCellViewModel( + jotConflict: businessModel, + repository: JotConflictRepositoryMock() + ) + + // Then + XCTAssertEqual(viewModel.name, "note") + XCTAssertEqual(viewModel.infoText, "Mac") + } + + func test_init_givenJotFileVersionWithoutSavingComputer_setsInfoTextToNa() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let businessModel = JotConflictBusinessModel( + name: "note", + jotFileInfo: jotFileInfo, + jotFileVersion: JotFileVersion(localizedNameOfSavingComputer: nil, info: jotFileInfo) + ) + + // When + let viewModel = JotConflictCellViewModel( + jotConflict: businessModel, + repository: JotConflictRepositoryMock() + ) + + // Then + XCTAssertEqual(viewModel.infoText, "n/a") + } + + func test_getPreviewImage_forwardsJotFileInfoAndVersionToRepository() async throws { + // Given + let getPreviewImageExpectation = XCTestExpectation( + description: "JotConflictRepositoryMock.getPreviewImageProvider is called." + ) + let expectedImage = UIImage() + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let jotFileVersion = JotFileVersion(localizedNameOfSavingComputer: "Mac", info: jotFileInfo) + let businessModel = JotConflictBusinessModel( + name: "note", + jotFileInfo: jotFileInfo, + jotFileVersion: jotFileVersion + ) + let repositoryMock = JotConflictRepositoryMock( + getPreviewImageProvider: { receivedInfo, receivedVersion, receivedStyle, receivedScale in + // Then + XCTAssertEqual(receivedInfo, jotFileInfo) + XCTAssertEqual(receivedVersion, jotFileVersion) + XCTAssertEqual(receivedStyle, .dark) + XCTAssertEqual(receivedScale, 3.0) + getPreviewImageExpectation.fulfill() + return expectedImage + } + ) + let viewModel = JotConflictCellViewModel( + jotConflict: businessModel, + repository: repositoryMock + ) + + // When + let image = await viewModel.getPreviewImage(userInterfaceStyle: .dark, displayScale: 3.0) + + // Then + XCTAssertIdentical(image, expectedImage) + await fulfillment(of: [getPreviewImageExpectation], timeout: 0.2) + } + + func test_handleAction_givenTap_doesNothing() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let viewModel = JotConflictCellViewModel( + jotConflict: JotConflictBusinessModel( + name: "note", + jotFileInfo: jotFileInfo, + jotFileVersion: JotFileVersion(localizedNameOfSavingComputer: nil, info: jotFileInfo) + ), + repository: JotConflictRepositoryMock() + ) + + // When + viewModel.handle(action: .tap) + + // Then + XCTAssertEqual(viewModel.name, "note") + } +} diff --git a/Tests/JotConflictPage/JotConflictRepositoryTests.swift b/Tests/JotConflictPage/JotConflictRepositoryTests.swift new file mode 100644 index 0000000..785e062 --- /dev/null +++ b/Tests/JotConflictPage/JotConflictRepositoryTests.swift @@ -0,0 +1,166 @@ +import UIKit +import XCTest + +@testable import Jottre + +final class JotConflictRepositoryTests: XCTestCase { + + func test_resolveVersionConflicts_forwardsToJotFileConflictService() async throws { + // Given + let resolveVersionConflictsExpectation = XCTestExpectation( + description: "JotFileConflictServiceMock.resolveVersionConflictsProvider is called." + ) + let inputInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let inputVersions = [ + JotFileVersion(localizedNameOfSavingComputer: "Mac", info: inputInfo), + JotFileVersion(localizedNameOfSavingComputer: "iPad", info: inputInfo), + ] + let jotFileConflictServiceMock = JotFileConflictServiceMock( + resolveVersionConflictsProvider: { receivedInfo, receivedVersions in + // Then + XCTAssertEqual(receivedInfo, inputInfo) + XCTAssertEqual(receivedVersions, inputVersions) + resolveVersionConflictsExpectation.fulfill() + } + ) + let repository = JotConflictRepository( + jotFileConflictService: jotFileConflictServiceMock, + jotFilePreviewImageService: JotFilePreviewImageServiceMock() + ) + + // When + try repository.resolveVersionConflicts(jotFileInfo: inputInfo, resolvedVersions: inputVersions) + + // Then + await fulfillment(of: [resolveVersionConflictsExpectation], timeout: 0.2) + } + + func test_getPreviewImage_givenCopyVersionToTemporaryReturnsNil_usesOriginalInfo() async throws { + // Given + let getPreviewImageDataExpectation = XCTestExpectation( + description: "JotFilePreviewImageServiceMock.getPreviewImageDataProvider is called with original info." + ) + let originalInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let imageData = try XCTUnwrap(UIImage(systemName: "doc")?.pngData()) + let jotFileConflictServiceMock = JotFileConflictServiceMock( + copyVersionToTemporaryProvider: { _, _ in nil } + ) + let jotFilePreviewImageServiceMock = JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { receivedInfo, receivedStyle, receivedScale in + // Then + XCTAssertEqual(receivedInfo, originalInfo) + XCTAssertEqual(receivedStyle, .light) + XCTAssertEqual(receivedScale, 2.0) + getPreviewImageDataExpectation.fulfill() + return imageData + } + ) + let repository = JotConflictRepository( + jotFileConflictService: jotFileConflictServiceMock, + jotFilePreviewImageService: jotFilePreviewImageServiceMock + ) + + // When + let image = await repository.getPreviewImage( + jotFileInfo: originalInfo, + jotFileVersion: JotFileVersion(localizedNameOfSavingComputer: "Mac", info: originalInfo), + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + XCTAssertNotNil(image) + await fulfillment(of: [getPreviewImageDataExpectation], timeout: 0.2) + } + + func test_getPreviewImage_givenCopyVersionToTemporaryReturnsInfo_usesTemporaryInfoAndCleansUp() async throws { + // Given + let getPreviewImageDataExpectation = XCTestExpectation( + description: "JotFilePreviewImageServiceMock.getPreviewImageDataProvider is called with temporary info." + ) + let originalInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let temporaryURL = FileManager.default.temporaryDirectory + .appendingPathComponent(UUID().uuidString) + .appendingPathExtension("jot") + try Data().write(to: temporaryURL) + let temporaryInfo = JotFile.Info( + url: temporaryURL, + name: "tmp", + modificationDate: nil, + ubiquitousInfo: nil + ) + let imageData = try XCTUnwrap(UIImage(systemName: "doc")?.pngData()) + let jotFileConflictServiceMock = JotFileConflictServiceMock( + copyVersionToTemporaryProvider: { _, _ in temporaryInfo } + ) + let jotFilePreviewImageServiceMock = JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { receivedInfo, _, _ in + // Then + XCTAssertEqual(receivedInfo, temporaryInfo) + getPreviewImageDataExpectation.fulfill() + return imageData + } + ) + let repository = JotConflictRepository( + jotFileConflictService: jotFileConflictServiceMock, + jotFilePreviewImageService: jotFilePreviewImageServiceMock + ) + + // When + let image = await repository.getPreviewImage( + jotFileInfo: originalInfo, + jotFileVersion: JotFileVersion(localizedNameOfSavingComputer: "Mac", info: originalInfo), + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + XCTAssertNotNil(image) + XCTAssertFalse(FileManager.default.fileExists(atPath: temporaryURL.path)) + await fulfillment(of: [getPreviewImageDataExpectation], timeout: 0.2) + } + + func test_getPreviewImage_givenPreviewImageServiceThrows_returnsNil() async throws { + // Given + let originalInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let repository = JotConflictRepository( + jotFileConflictService: JotFileConflictServiceMock(), + jotFilePreviewImageService: JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { _, _, _ in + throw NSError(domain: "test", code: 0) + } + ) + ) + + // When + let image = await repository.getPreviewImage( + jotFileInfo: originalInfo, + jotFileVersion: JotFileVersion(localizedNameOfSavingComputer: "Mac", info: originalInfo), + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + XCTAssertNil(image) + } +} diff --git a/Tests/JotConflictPage/JotFileConflictServiceTests.swift b/Tests/JotConflictPage/JotFileConflictServiceTests.swift new file mode 100644 index 0000000..0848664 --- /dev/null +++ b/Tests/JotConflictPage/JotFileConflictServiceTests.swift @@ -0,0 +1,130 @@ +import XCTest + +@testable import Jottre + +final class JotFileConflictServiceTests: XCTestCase { + + func test_getConfictingVersions_givenNilFromUnderlyingService_returnsNil() { + // Given + let service = JotFileConflictService( + fileConflictService: FileConflictServiceMock( + getConflictingVersionsProvider: { _ in nil } + ) + ) + + // When + let result = service.getConfictingVersions(jotFileInfo: makeJotFileInfo()) + + // Then + XCTAssertNil(result) + } + + func test_getConfictingVersions_givenEmptyArrayFromUnderlyingService_returnsNil() { + // Given + let service = JotFileConflictService( + fileConflictService: FileConflictServiceMock( + getConflictingVersionsProvider: { _ in [] } + ) + ) + + // When + let result = service.getConfictingVersions(jotFileInfo: makeJotFileInfo()) + + // Then + XCTAssertNil(result) + } + + func test_resolveVersionConflicts_forwardsURLsToUnderlyingService() async throws { + // Given + let resolveVersionConflictsExpectation = XCTestExpectation( + description: "FileConflictServiceMock.resolveVersionConflictsProvider is called." + ) + let inputInfo = makeJotFileInfo() + let versionURLA = URL(staticString: "file:///tmp/version-a.jot") + let versionURLB = URL(staticString: "file:///tmp/version-b.jot") + let versionInfos = [ + JotFileVersion( + localizedNameOfSavingComputer: "A", + info: JotFile.Info(url: versionURLA, name: "a", modificationDate: nil, ubiquitousInfo: nil) + ), + JotFileVersion( + localizedNameOfSavingComputer: "B", + info: JotFile.Info(url: versionURLB, name: "b", modificationDate: nil, ubiquitousInfo: nil) + ), + ] + let fileConflictServiceMock = FileConflictServiceMock( + resolveVersionConflictsProvider: { receivedFileURL, receivedResolvedVersions in + // Then + XCTAssertEqual(receivedFileURL, inputInfo.url) + XCTAssertEqual(receivedResolvedVersions, [versionURLA, versionURLB]) + resolveVersionConflictsExpectation.fulfill() + } + ) + let service = JotFileConflictService(fileConflictService: fileConflictServiceMock) + + // When + try service.resolveVersionConflicts(jotFileInfo: inputInfo, resolvedVersions: versionInfos) + + // Then + await fulfillment(of: [resolveVersionConflictsExpectation], timeout: 0.2) + } + + func test_copyVersionToTemporary_givenUnderlyingReturnsURL_returnsInfoWithTemporaryURLAndOriginalMetadata() throws { + // Given + let temporaryURL = URL(staticString: "file:///tmp/copy.jot") + let fileConflictServiceMock = FileConflictServiceMock( + copyVersionToTemporaryProvider: { _, _ in temporaryURL } + ) + let service = JotFileConflictService(fileConflictService: fileConflictServiceMock) + let modificationDate = Date(timeIntervalSince1970: 1_000) + let versionInfo = JotFile.Info( + url: URL(staticString: "file:///cloud/version.jot"), + name: "version", + modificationDate: modificationDate, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + let jotFileVersion = JotFileVersion(localizedNameOfSavingComputer: "Mac", info: versionInfo) + + // When + let result = try service.copyVersionToTemporary( + jotFileInfo: makeJotFileInfo(), + jotFileVersion: jotFileVersion + ) + + // Then + let unwrapped = try XCTUnwrap(result) + XCTAssertEqual(unwrapped.url, temporaryURL) + XCTAssertEqual(unwrapped.name, versionInfo.name) + XCTAssertEqual(unwrapped.modificationDate, modificationDate) + XCTAssertEqual(unwrapped.ubiquitousInfo, versionInfo.ubiquitousInfo) + } + + func test_copyVersionToTemporary_givenUnderlyingReturnsNil_returnsNil() throws { + // Given + let service = JotFileConflictService( + fileConflictService: FileConflictServiceMock(copyVersionToTemporaryProvider: { _, _ in nil }) + ) + let jotFileVersion = JotFileVersion( + localizedNameOfSavingComputer: nil, + info: makeJotFileInfo() + ) + + // When + let result = try service.copyVersionToTemporary( + jotFileInfo: makeJotFileInfo(), + jotFileVersion: jotFileVersion + ) + + // Then + XCTAssertNil(result) + } + + private func makeJotFileInfo() -> JotFile.Info { + JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + } +} diff --git a/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift b/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift index 0cb3dba..493f473 100644 --- a/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift +++ b/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift @@ -70,6 +70,80 @@ final class CachedJotFilePreviewImageServiceTests: XCTestCase { XCTAssertEqual(underlyingCallCount.value, 1) } + func test_getPreviewImageData_givenColdCache_writesThroughToDiskCache() async throws { + // Given + let writeFileExpectation = XCTestExpectation(description: "FileServiceMock.writeFileProvider is called.") + let producedData = Data([4, 5, 6]) + let writtenURL = LockIsolated(nil) + let writtenData = LockIsolated(nil) + let service = CachedJotFilePreviewImageService( + localFileService: FileServiceMock( + temporaryDirectoryProvider: { + FileManager.default.temporaryDirectory + .appendingPathComponent(UUID().uuidString, isDirectory: true) + }, + readFileProvider: { _ in throw NSError(domain: "noDiskCache", code: 0) }, + writeFileProvider: { receivedURL, receivedData in + writtenURL.withValue { $0 = receivedURL } + writtenData.withValue { $0 = receivedData } + writeFileExpectation.fulfill() + } + ), + jotFilePreviewImageService: JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { _, _, _ in producedData } + ) + ) + + // When + let data = try await service.getPreviewImageData( + jotFileInfo: info, + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + XCTAssertEqual(data, producedData) + await fulfillment(of: [writeFileExpectation], timeout: 0.5) + XCTAssertEqual(writtenData.value, producedData) + XCTAssertNotNil(writtenURL.value) + } + + func test_getPreviewImageData_givenJotFileInfoWithoutModificationDate_skipsDiskCache() async throws { + // Given + let readFileExpectation = XCTestExpectation(description: "FileServiceMock.readFileProvider is not called.") + readFileExpectation.isInverted = true + let writeFileExpectation = XCTestExpectation(description: "FileServiceMock.writeFileProvider is not called.") + writeFileExpectation.isInverted = true + let undatedInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let service = CachedJotFilePreviewImageService( + localFileService: FileServiceMock( + readFileProvider: { _ in + readFileExpectation.fulfill() + return Data() + }, + writeFileProvider: { _, _ in writeFileExpectation.fulfill() } + ), + jotFilePreviewImageService: JotFilePreviewImageServiceMock( + getPreviewImageDataProvider: { _, _, _ in Data([1]) } + ) + ) + + // When + _ = try await service.getPreviewImageData( + jotFileInfo: undatedInfo, + userInterfaceStyle: .light, + displayScale: 2.0 + ) + + // Then + await fulfillment(of: [readFileExpectation, writeFileExpectation], timeout: 0.2) + } + func test_getPreviewImageData_givenDiskCacheHit_skipsUnderlyingService() async throws { // Given let cachedData = Data([42]) diff --git a/Tests/JotsPage/JotCellViewModelTests.swift b/Tests/JotsPage/JotCellViewModelTests.swift new file mode 100644 index 0000000..89cac39 --- /dev/null +++ b/Tests/JotsPage/JotCellViewModelTests.swift @@ -0,0 +1,138 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class JotCellViewModelTests: XCTestCase { + + func test_init_givenIsDownloadingTrue_setsPreviewToLoadingIndicator() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .notDownloaded, isDownloading: true) + ) + let businessModel = JotBusinessModel(jotFileInfo: jotFileInfo) + + // When + let viewModel = JotCellViewModel( + jot: businessModel, + jotMenuConfigurations: makeEmptyJotMenuConfigurations(), + repository: JotsRepositoryMock(), + onAction: {} + ) + + // Then + XCTAssertEqual(viewModel.preview, .loadingIndicator) + XCTAssertEqual(viewModel.name, "note") + } + + func test_init_givenDownloadedAndNotDownloading_setsPreviewToThumbnail() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .current, isDownloading: false) + ) + + // When + let viewModel = JotCellViewModel( + jot: JotBusinessModel(jotFileInfo: jotFileInfo), + jotMenuConfigurations: makeEmptyJotMenuConfigurations(), + repository: JotsRepositoryMock(), + onAction: {} + ) + + // Then + XCTAssertEqual(viewModel.preview, .thumbnail) + } + + func test_init_givenNotDownloadedAndNotDownloading_setsPreviewToCloudImage() { + // Given + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///cloud/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: UbiquitousInfo(downloadStatus: .notDownloaded, isDownloading: false) + ) + + // When + let viewModel = JotCellViewModel( + jot: JotBusinessModel(jotFileInfo: jotFileInfo), + jotMenuConfigurations: makeEmptyJotMenuConfigurations(), + repository: JotsRepositoryMock(), + onAction: {} + ) + + // Then + XCTAssertEqual(viewModel.preview, .cloudImage) + } + + func test_handleAction_givenTap_invokesOnAction() async { + // Given + let onActionExpectation = XCTestExpectation(description: "onAction is called.") + let jotFileInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let viewModel = JotCellViewModel( + jot: JotBusinessModel(jotFileInfo: jotFileInfo), + jotMenuConfigurations: makeEmptyJotMenuConfigurations(), + repository: JotsRepositoryMock(), + onAction: { onActionExpectation.fulfill() } + ) + + // When + viewModel.handle(action: .tap) + + // Then + await fulfillment(of: [onActionExpectation], timeout: 0.2) + } + + func test_getPreviewImage_forwardsToRepositoryWithJotFileInfo() async throws { + // Given + let getPreviewImageProviderExpectation = XCTestExpectation( + description: "JotsRepositoryMock.getPreviewImageProvider is called." + ) + let expectedImage = UIImage() + let expectedFileURL = URL(staticString: "file:///tmp/note.jot") + let jotFileInfo = JotFile.Info( + url: expectedFileURL, + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let repositoryMock = JotsRepositoryMock( + getPreviewImageProvider: { receivedInfo, receivedStyle, receivedScale in + // Then + XCTAssertEqual(receivedInfo.url, expectedFileURL) + XCTAssertEqual(receivedStyle, .dark) + XCTAssertEqual(receivedScale, 3.0) + getPreviewImageProviderExpectation.fulfill() + return expectedImage + } + ) + let viewModel = JotCellViewModel( + jot: JotBusinessModel(jotFileInfo: jotFileInfo), + jotMenuConfigurations: makeEmptyJotMenuConfigurations(), + repository: repositoryMock, + onAction: {} + ) + + // When + let image = await viewModel.getPreviewImage(userInterfaceStyle: .dark, displayScale: 3.0) + + // Then + XCTAssertIdentical(image, expectedImage) + await fulfillment(of: [getPreviewImageProviderExpectation], timeout: 0.2) + } + + private func makeEmptyJotMenuConfigurations() -> JotMenuConfigurations { + JotMenuConfigurations { _ in [] } + } +} diff --git a/Tests/JotsPage/ShareJotRepositoryTests.swift b/Tests/JotsPage/ShareJotRepositoryTests.swift new file mode 100644 index 0000000..e20c3fa --- /dev/null +++ b/Tests/JotsPage/ShareJotRepositoryTests.swift @@ -0,0 +1,114 @@ +@preconcurrency import PencilKit +import UIKit +import XCTest + +@testable import Jottre + +final class ShareJotRepositoryTests: XCTestCase { + + private var temporaryDirectory: URL! + + override func setUpWithError() throws { + try super.setUpWithError() + temporaryDirectory = FileManager.default.temporaryDirectory + .appendingPathComponent(UUID().uuidString, isDirectory: true) + try FileManager.default.createDirectory( + at: temporaryDirectory, + withIntermediateDirectories: true + ) + } + + override func tearDownWithError() throws { + try? FileManager.default.removeItem(at: temporaryDirectory) + temporaryDirectory = nil + try super.tearDownWithError() + } + + func test_exportJot_givenPDFFormat_writesPDFFileToTemporaryDirectoryAndReturnsItsURL() async throws { + // Given + let repository = makeRepository() + + // When + let resultURL = try await repository.exportJot(jotFileInfo: makeJotFileInfo(), format: .pdf) + + // Then + XCTAssertEqual(resultURL.lastPathComponent, "note.pdf") + XCTAssertEqual(resultURL.deletingLastPathComponent(), temporaryDirectory) + XCTAssertTrue(FileManager.default.fileExists(atPath: resultURL.path)) + let header = try Data(contentsOf: resultURL).prefix(4) + XCTAssertEqual(Array(header), Array("%PDF".utf8)) + } + + func test_exportJot_givenJPGFormat_writesJPGFileToTemporaryDirectoryAndReturnsItsURL() async throws { + // Given + let repository = makeRepository() + + // When + let resultURL = try await repository.exportJot(jotFileInfo: makeJotFileInfo(), format: .jpg) + + // Then + XCTAssertEqual(resultURL.lastPathComponent, "note.jpg") + XCTAssertTrue(FileManager.default.fileExists(atPath: resultURL.path)) + let bytes = try Data(contentsOf: resultURL).prefix(3) + XCTAssertEqual(Array(bytes), [0xFF, 0xD8, 0xFF]) + } + + func test_exportJot_givenPNGFormat_writesPNGFileToTemporaryDirectoryAndReturnsItsURL() async throws { + // Given + let repository = makeRepository() + + // When + let resultURL = try await repository.exportJot(jotFileInfo: makeJotFileInfo(), format: .png) + + // Then + XCTAssertEqual(resultURL.lastPathComponent, "note.png") + XCTAssertTrue(FileManager.default.fileExists(atPath: resultURL.path)) + let bytes = try Data(contentsOf: resultURL).prefix(8) + XCTAssertEqual(Array(bytes), [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]) + } + + func test_exportJot_givenJotFileServiceThrows_propagatesError() async { + // Given + struct UnexpectedError: Error {} + let repository = ShareJotRepository( + jotFileService: JotFileServiceMock( + readJotFileProvider: { _ in throw UnexpectedError() } + ), + fileService: FileServiceMock( + temporaryDirectoryProvider: { [temporaryDirectory] in temporaryDirectory! } + ) + ) + + // When + Then + do { + _ = try await repository.exportJot(jotFileInfo: makeJotFileInfo(), format: .pdf) + XCTFail("Expected exportJot to throw") + } catch is UnexpectedError { + // Expected + } catch { + XCTFail("Unexpected error: \(error)") + } + } + + private func makeRepository() -> ShareJotRepository { + ShareJotRepository( + jotFileService: JotFileServiceMock( + readJotFileProvider: { jotFileInfo in + JotFile(info: jotFileInfo, jot: Jot.makeEmpty()) + } + ), + fileService: FileServiceMock( + temporaryDirectoryProvider: { [temporaryDirectory] in temporaryDirectory! } + ) + ) + } + + private func makeJotFileInfo() -> JotFile.Info { + JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + } +} diff --git a/Tests/Mocks/CloudMigrationRepositoryMock.swift b/Tests/Mocks/CloudMigrationRepositoryMock.swift new file mode 100644 index 0000000..ea675c0 --- /dev/null +++ b/Tests/Mocks/CloudMigrationRepositoryMock.swift @@ -0,0 +1,69 @@ +import Foundation +import UIKit + +@testable import Jottre + +final class CloudMigrationRepositoryMock: CloudMigrationRepositoryProtocol { + + private let getJotFilesProvider: @Sendable () -> AsyncThrowingStream<[CloudMigrationJotBusinessModel], Error> + private let moveJotFileProvider: + @Sendable (_ jotFileInfo: JotFile.Info, _ shouldBecomeUbiquitous: Bool) async throws -> Void + private let getShouldShowCloudMigrationProvider: @Sendable () -> Bool + private let markCloudMigrationPageDoneProvider: @Sendable () -> Void + private let getPreviewImageProvider: + @Sendable ( + _ jotFileInfo: JotFile.Info, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async -> UIImage? + + init( + getJotFilesProvider: + @Sendable @escaping () -> AsyncThrowingStream<[CloudMigrationJotBusinessModel], Error> = { + AsyncThrowingStream { $0.finish() } + }, + moveJotFileProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ shouldBecomeUbiquitous: Bool) async throws -> Void = { + _, + _ in + }, + getShouldShowCloudMigrationProvider: @Sendable @escaping () -> Bool = { false }, + markCloudMigrationPageDoneProvider: @Sendable @escaping () -> Void = {}, + getPreviewImageProvider: + @Sendable @escaping ( + _ jotFileInfo: JotFile.Info, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async -> UIImage? = { _, _, _ in nil } + ) { + self.getJotFilesProvider = getJotFilesProvider + self.moveJotFileProvider = moveJotFileProvider + self.getShouldShowCloudMigrationProvider = getShouldShowCloudMigrationProvider + self.markCloudMigrationPageDoneProvider = markCloudMigrationPageDoneProvider + self.getPreviewImageProvider = getPreviewImageProvider + } + + func getJotFiles() -> AsyncThrowingStream<[CloudMigrationJotBusinessModel], Error> { + getJotFilesProvider() + } + + func moveJotFile(jotFileInfo: JotFile.Info, shouldBecomeUbiquitous: Bool) async throws { + try await moveJotFileProvider(jotFileInfo, shouldBecomeUbiquitous) + } + + func getShouldShowCloudMigration() -> Bool { + getShouldShowCloudMigrationProvider() + } + + func markCloudMigrationPageDone() { + markCloudMigrationPageDoneProvider() + } + + func getPreviewImage( + jotFileInfo: JotFile.Info, + userInterfaceStyle: UIUserInterfaceStyle, + displayScale: CGFloat + ) async -> UIImage? { + await getPreviewImageProvider(jotFileInfo, userInterfaceStyle, displayScale) + } +} diff --git a/Tests/Mocks/FileConflictServiceMock.swift b/Tests/Mocks/FileConflictServiceMock.swift new file mode 100644 index 0000000..3748606 --- /dev/null +++ b/Tests/Mocks/FileConflictServiceMock.swift @@ -0,0 +1,34 @@ +import Foundation + +@testable import Jottre + +final class FileConflictServiceMock: FileConflictServiceProtocol { + + private let getConflictingVersionsProvider: @Sendable (_ fileURL: URL) -> [NSFileVersion]? + private let resolveVersionConflictsProvider: @Sendable (_ fileURL: URL, _ resolvedVersions: [URL]) throws -> Void + private let copyVersionToTemporaryProvider: @Sendable (_ fileURL: URL, _ versionURL: URL) throws -> URL? + + init( + getConflictingVersionsProvider: @Sendable @escaping (_ fileURL: URL) -> [NSFileVersion]? = { _ in nil }, + resolveVersionConflictsProvider: + @Sendable @escaping (_ fileURL: URL, _ resolvedVersions: [URL]) throws -> Void = { _, _ in }, + copyVersionToTemporaryProvider: + @Sendable @escaping (_ fileURL: URL, _ versionURL: URL) throws -> URL? = { _, _ in nil } + ) { + self.getConflictingVersionsProvider = getConflictingVersionsProvider + self.resolveVersionConflictsProvider = resolveVersionConflictsProvider + self.copyVersionToTemporaryProvider = copyVersionToTemporaryProvider + } + + func getConflictingVersions(fileURL: URL) -> [NSFileVersion]? { + getConflictingVersionsProvider(fileURL) + } + + func resolveVersionConflicts(fileURL: URL, resolvedVersions: [URL]) throws { + try resolveVersionConflictsProvider(fileURL, resolvedVersions) + } + + func copyVersionToTemporary(fileURL: URL, versionURL: URL) throws -> URL? { + try copyVersionToTemporaryProvider(fileURL, versionURL) + } +} diff --git a/Tests/Mocks/JotConflictRepositoryMock.swift b/Tests/Mocks/JotConflictRepositoryMock.swift new file mode 100644 index 0000000..0b805fd --- /dev/null +++ b/Tests/Mocks/JotConflictRepositoryMock.swift @@ -0,0 +1,51 @@ +import Foundation +import UIKit + +@testable import Jottre + +final class JotConflictRepositoryMock: JotConflictRepositoryProtocol { + + private let resolveVersionConflictsProvider: + @Sendable (_ jotFileInfo: JotFile.Info, _ resolvedVersions: [JotFileVersion]) throws -> Void + private let getPreviewImageProvider: + @Sendable ( + _ jotFileInfo: JotFile.Info, + _ jotFileVersion: JotFileVersion, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async -> UIImage? + + init( + resolveVersionConflictsProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ resolvedVersions: [JotFileVersion]) throws -> Void = { + _, + _ in + }, + getPreviewImageProvider: + @Sendable @escaping ( + _ jotFileInfo: JotFile.Info, + _ jotFileVersion: JotFileVersion, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async -> UIImage? = { _, _, _, _ in nil } + ) { + self.resolveVersionConflictsProvider = resolveVersionConflictsProvider + self.getPreviewImageProvider = getPreviewImageProvider + } + + func resolveVersionConflicts( + jotFileInfo: JotFile.Info, + resolvedVersions: [JotFileVersion] + ) throws { + try resolveVersionConflictsProvider(jotFileInfo, resolvedVersions) + } + + func getPreviewImage( + jotFileInfo: JotFile.Info, + jotFileVersion: JotFileVersion, + userInterfaceStyle: UIUserInterfaceStyle, + displayScale: CGFloat + ) async -> UIImage? { + await getPreviewImageProvider(jotFileInfo, jotFileVersion, userInterfaceStyle, displayScale) + } +} diff --git a/Tests/Mocks/JotsRepositoryMock.swift b/Tests/Mocks/JotsRepositoryMock.swift new file mode 100644 index 0000000..0b0d864 --- /dev/null +++ b/Tests/Mocks/JotsRepositoryMock.swift @@ -0,0 +1,79 @@ +import Foundation +import UIKit + +@testable import Jottre + +final class JotsRepositoryMock: JotsRepositoryProtocol { + + private let getJotFilesProvider: @Sendable () -> AsyncThrowingStream<[JotFile.Info], Error> + private let shouldShowEnableICloudButtonProvider: @Sendable () -> Bool + private let duplicateProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> JotFile.Info + private let downloadProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> Void + private let getPreviewImageProvider: + @Sendable ( + _ jotFileInfo: JotFile.Info, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async -> UIImage? + private let supportsMultipleScenesProvider: @MainActor @Sendable () -> Bool + private let isIPadOSProvider: @MainActor @Sendable () -> Bool + + init( + getJotFilesProvider: @Sendable @escaping () -> AsyncThrowingStream<[JotFile.Info], Error> = { + AsyncThrowingStream { $0.finish() } + }, + shouldShowEnableICloudButtonProvider: @Sendable @escaping () -> Bool = { false }, + duplicateProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> JotFile.Info = { $0 }, + downloadProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> Void = { _ in }, + getPreviewImageProvider: + @Sendable @escaping ( + _ jotFileInfo: JotFile.Info, + _ userInterfaceStyle: UIUserInterfaceStyle, + _ displayScale: CGFloat + ) async -> UIImage? = { _, _, _ in nil }, + supportsMultipleScenesProvider: @MainActor @Sendable @escaping () -> Bool = { false }, + isIPadOSProvider: @MainActor @Sendable @escaping () -> Bool = { false } + ) { + self.getJotFilesProvider = getJotFilesProvider + self.shouldShowEnableICloudButtonProvider = shouldShowEnableICloudButtonProvider + self.duplicateProvider = duplicateProvider + self.downloadProvider = downloadProvider + self.getPreviewImageProvider = getPreviewImageProvider + self.supportsMultipleScenesProvider = supportsMultipleScenesProvider + self.isIPadOSProvider = isIPadOSProvider + } + + func getJotFiles() -> AsyncThrowingStream<[JotFile.Info], Error> { + getJotFilesProvider() + } + + func shouldShowEnableICloudButton() -> Bool { + shouldShowEnableICloudButtonProvider() + } + + func duplicate(jotFileInfo: JotFile.Info) throws -> JotFile.Info { + try duplicateProvider(jotFileInfo) + } + + func download(jotFileInfo: JotFile.Info) throws { + try downloadProvider(jotFileInfo) + } + + func getPreviewImage( + jotFileInfo: JotFile.Info, + userInterfaceStyle: UIUserInterfaceStyle, + displayScale: CGFloat + ) async -> UIImage? { + await getPreviewImageProvider(jotFileInfo, userInterfaceStyle, displayScale) + } + + @MainActor + func supportsMultipleScenes() -> Bool { + supportsMultipleScenesProvider() + } + + @MainActor + func isIPadOS() -> Bool { + isIPadOSProvider() + } +} diff --git a/Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift b/Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift new file mode 100644 index 0000000..8a69c55 --- /dev/null +++ b/Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift @@ -0,0 +1,36 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class IOS18SymbolBarButtonItemFactoryTests: XCTestCase { + + func test_make_givenActionPrimary_returnsBarButtonItemWrappingButtonWithAction() { + // Given + let factory = IOS18SymbolBarButtonItemFactory() + let action = UIAction { _ in } + + // When + let barButtonItem = factory.make(symbolName: "plus", primaryAction: .action(action)) + + // Then + let button = try? XCTUnwrap(barButtonItem.customView as? UIButton) + XCTAssertNotNil(button) + XCTAssertFalse(button?.showsMenuAsPrimaryAction ?? true) + } + + func test_make_givenMenuPrimary_returnsBarButtonItemWrappingButtonWithMenu() throws { + // Given + let factory = IOS18SymbolBarButtonItemFactory() + let menu = UIMenu(title: "Menu", children: []) + + // When + let barButtonItem = factory.make(symbolName: "ellipsis", primaryAction: .menu(menu)) + + // Then + let button = try XCTUnwrap(barButtonItem.customView as? UIButton) + XCTAssertTrue(button.showsMenuAsPrimaryAction) + XCTAssertNotNil(button.menu) + } +} diff --git a/Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift b/Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift new file mode 100644 index 0000000..8ff789d --- /dev/null +++ b/Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift @@ -0,0 +1,21 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class IOS18TextBarButtonItemFactoryTests: XCTestCase { + + func test_make_returnsBarButtonItemWrappingButtonConfiguredWithTitle() throws { + // Given + let factory = IOS18TextBarButtonItemFactory() + let action = UIAction { _ in } + + // When + let barButtonItem = factory.make(title: "Save", primaryAction: action) + + // Then + let button = try XCTUnwrap(barButtonItem.customView as? UIButton) + XCTAssertEqual(button.configuration?.title, "Save") + } +} diff --git a/Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift b/Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift new file mode 100644 index 0000000..50d8411 --- /dev/null +++ b/Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift @@ -0,0 +1,50 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class SettingsDropdownCellViewModelTests: XCTestCase { + + func test_init_storesNameCurrentAndOptionsFromBusinessModel() { + // Given + let light = SettingsDropdownBusinessModel.Option(label: "Light", value: "light") + let dark = SettingsDropdownBusinessModel.Option(label: "Dark", value: "dark") + let businessModel = SettingsDropdownBusinessModel( + name: "Appearance", + current: light, + options: [light, dark] + ) + + // When + let viewModel = SettingsDropdownCellViewModel( + settingsDropdown: businessModel, + onAction: { _ in } + ) + + // Then + XCTAssertEqual(viewModel.name, "Appearance") + XCTAssertEqual(viewModel.current, light) + XCTAssertEqual(viewModel.options, [light, dark]) + } + + func test_handleAction_givenTap_doesNotInvokeOnAction() async { + // Given + let onActionExpectation = XCTestExpectation(description: "onAction is not called for .tap") + onActionExpectation.isInverted = true + let option = SettingsDropdownBusinessModel.Option(label: "Light", value: "light") + let viewModel = SettingsDropdownCellViewModel( + settingsDropdown: SettingsDropdownBusinessModel( + name: "Appearance", + current: option, + options: [option] + ), + onAction: { _ in onActionExpectation.fulfill() } + ) + + // When + viewModel.handle(action: .tap) + + // Then + await fulfillment(of: [onActionExpectation], timeout: 0.05) + } +} diff --git a/Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift b/Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift new file mode 100644 index 0000000..a7d0ce4 --- /dev/null +++ b/Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift @@ -0,0 +1,51 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class SettingsExternalLinkCellViewModelTests: XCTestCase { + + func test_init_storesNameAndInfoFromBusinessModel() { + // Given + let businessModel = SettingsExternalLinkBusinessModel(name: "GitHub", info: "Open repository") + + // When + let viewModel = SettingsExternalLinkCellViewModel( + settingsExternalLink: businessModel, + onAction: {} + ) + + // Then + XCTAssertEqual(viewModel.name, "GitHub") + XCTAssertEqual(viewModel.info, "Open repository") + } + + func test_init_givenNilInfoBusinessModel_storesNilInfo() { + // Given + let businessModel = SettingsExternalLinkBusinessModel(name: "GitHub", info: nil) + + // When + let viewModel = SettingsExternalLinkCellViewModel( + settingsExternalLink: businessModel, + onAction: {} + ) + + // Then + XCTAssertNil(viewModel.info) + } + + func test_handleAction_givenTap_invokesOnAction() async { + // Given + let onActionExpectation = XCTestExpectation(description: "onAction is called.") + let viewModel = SettingsExternalLinkCellViewModel( + settingsExternalLink: SettingsExternalLinkBusinessModel(name: "GitHub", info: nil), + onAction: { onActionExpectation.fulfill() } + ) + + // When + viewModel.handle(action: .tap) + + // Then + await fulfillment(of: [onActionExpectation], timeout: 0.2) + } +} diff --git a/Tests/SettingsPage/SettingsInfoCellViewModelTests.swift b/Tests/SettingsPage/SettingsInfoCellViewModelTests.swift new file mode 100644 index 0000000..b9175d8 --- /dev/null +++ b/Tests/SettingsPage/SettingsInfoCellViewModelTests.swift @@ -0,0 +1,32 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class SettingsInfoCellViewModelTests: XCTestCase { + + func test_init_storesNameAndValueFromBusinessModel() { + // Given + let businessModel = SettingsInfoBusinessModel(name: "Version", value: "1.0.0") + + // When + let viewModel = SettingsInfoCellViewModel(settingsInfo: businessModel) + + // Then + XCTAssertEqual(viewModel.name, "Version") + XCTAssertEqual(viewModel.value, "1.0.0") + } + + func test_handleAction_givenTap_doesNothing() { + // Given + let viewModel = SettingsInfoCellViewModel( + settingsInfo: SettingsInfoBusinessModel(name: "Version", value: "1.0.0") + ) + + // When + viewModel.handle(action: .tap) + + // Then + XCTAssertEqual(viewModel.value, "1.0.0") + } +} diff --git a/Tests/SettingsPage/SettingsToggleCellViewModelTests.swift b/Tests/SettingsPage/SettingsToggleCellViewModelTests.swift new file mode 100644 index 0000000..9aefc6a --- /dev/null +++ b/Tests/SettingsPage/SettingsToggleCellViewModelTests.swift @@ -0,0 +1,32 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class SettingsToggleCellViewModelTests: XCTestCase { + + func test_init_storesNameAndIsOnFromBusinessModel() { + // Given + let businessModel = SettingsToggleBusinessModel(name: "iCloud", isOn: true) + + // When + let viewModel = SettingsToggleCellViewModel(settingsToggle: businessModel) + + // Then + XCTAssertEqual(viewModel.name, "iCloud") + XCTAssertTrue(viewModel.isOn) + } + + func test_handleAction_givenTap_doesNothing() { + // Given + let viewModel = SettingsToggleCellViewModel( + settingsToggle: SettingsToggleBusinessModel(name: "iCloud", isOn: false) + ) + + // When + viewModel.handle(action: .tap) + + // Then + XCTAssertFalse(viewModel.isOn) + } +} diff --git a/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift b/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift new file mode 100644 index 0000000..ecde69d --- /dev/null +++ b/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift @@ -0,0 +1,32 @@ +import UIKit +import XCTest + +@testable import Jottre + +final class NSLayoutConstraintWithPriorityTests: XCTestCase { + + func test_withPriority_setsPriorityAndReturnsSameConstraint() { + // Given + let view = UIView() + let constraint = view.widthAnchor.constraint(equalToConstant: 100) + + // When + let returned = constraint.withPriority(.defaultLow) + + // Then + XCTAssertEqual(constraint.priority, .defaultLow) + XCTAssertTrue(returned === constraint) + } + + func test_withPriority_givenChainedCalls_appliesLastValue() { + // Given + let view = UIView() + let constraint = view.widthAnchor.constraint(equalToConstant: 100) + + // When + _ = constraint.withPriority(.defaultLow).withPriority(.required) + + // Then + XCTAssertEqual(constraint.priority, .required) + } +} diff --git a/Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift b/Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift new file mode 100644 index 0000000..dad4b0a --- /dev/null +++ b/Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift @@ -0,0 +1,29 @@ +import UIKit +import XCTest + +@testable import Jottre + +final class UIColorAdaptiveBlackWhiteTests: XCTestCase { + + func test_adaptiveBlackWhite_givenLightUserInterfaceStyle_resolvesToWhite() { + // Given + let lightTraits = UITraitCollection(userInterfaceStyle: .light) + + // When + let resolved = UIColor.adaptiveBlackWhite.resolvedColor(with: lightTraits) + + // Then + XCTAssertEqual(resolved, UIColor.white) + } + + func test_adaptiveBlackWhite_givenDarkUserInterfaceStyle_resolvesToBlack() { + // Given + let darkTraits = UITraitCollection(userInterfaceStyle: .dark) + + // When + let resolved = UIColor.adaptiveBlackWhite.resolvedColor(with: darkTraits) + + // Then + XCTAssertEqual(resolved, UIColor.black) + } +} diff --git a/Tests/Utilities/UIFontPreferredFontTests.swift b/Tests/Utilities/UIFontPreferredFontTests.swift new file mode 100644 index 0000000..f26cfe4 --- /dev/null +++ b/Tests/Utilities/UIFontPreferredFontTests.swift @@ -0,0 +1,26 @@ +import UIKit +import XCTest + +@testable import Jottre + +final class UIFontPreferredFontTests: XCTestCase { + + func test_preferredFont_givenBodyTextStyleAndBoldWeight_returnsScaledBoldFont() { + // When + let font = UIFont.preferredFont(forTextStyle: .body, weight: .bold) + + // Then + let traits = font.fontDescriptor.symbolicTraits + XCTAssertTrue(traits.contains(.traitBold)) + XCTAssertGreaterThan(font.pointSize, 0) + } + + func test_preferredFont_givenLargerTextStyle_producesLargerOrEqualPointSize() { + // When + let captionFont = UIFont.preferredFont(forTextStyle: .caption2, weight: .regular) + let titleFont = UIFont.preferredFont(forTextStyle: .title1, weight: .regular) + + // Then + XCTAssertGreaterThan(titleFont.pointSize, captionFont.pointSize) + } +} diff --git a/Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift b/Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift new file mode 100644 index 0000000..151418c --- /dev/null +++ b/Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift @@ -0,0 +1,71 @@ +import UIKit +import XCTest + +@testable import Jottre + +final class UITraitCollectionHasRenderingChangeTests: XCTestCase { + + func test_hasRenderingChange_givenIdenticalTraits_returnsFalse() { + // Given + let traits = UITraitCollection(traitsFrom: [ + UITraitCollection(userInterfaceStyle: .light), + UITraitCollection(displayScale: 2.0), + ]) + + // When + let result = traits.hasRenderingChange(comparedTo: traits) + + // Then + XCTAssertFalse(result) + } + + func test_hasRenderingChange_givenNilPrevious_returnsTrue() { + // Given + let traits = UITraitCollection(traitsFrom: [ + UITraitCollection(userInterfaceStyle: .light), + UITraitCollection(displayScale: 2.0), + ]) + + // When + let result = traits.hasRenderingChange(comparedTo: nil) + + // Then + XCTAssertTrue(result) + } + + func test_hasRenderingChange_givenDifferingUserInterfaceStyle_returnsTrue() { + // Given + let lightTraits = UITraitCollection(traitsFrom: [ + UITraitCollection(userInterfaceStyle: .light), + UITraitCollection(displayScale: 2.0), + ]) + let darkTraits = UITraitCollection(traitsFrom: [ + UITraitCollection(userInterfaceStyle: .dark), + UITraitCollection(displayScale: 2.0), + ]) + + // When + let result = lightTraits.hasRenderingChange(comparedTo: darkTraits) + + // Then + XCTAssertTrue(result) + } + + func test_hasRenderingChange_givenDifferingDisplayScale_returnsTrue() { + // Given + let twoXTraits = UITraitCollection(traitsFrom: [ + UITraitCollection(userInterfaceStyle: .light), + UITraitCollection(displayScale: 2.0), + ]) + let threeXTraits = UITraitCollection(traitsFrom: [ + UITraitCollection(userInterfaceStyle: .light), + UITraitCollection(displayScale: 3.0), + ]) + + // When + let result = twoXTraits.hasRenderingChange(comparedTo: threeXTraits) + + // Then + XCTAssertTrue(result) + } +} From 5c8f36497424c45a48ef03d92d7b5bb7f39e083b Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Fri, 8 May 2026 21:24:57 +0200 Subject: [PATCH 4/9] Adds viewmodel/coordinator tests (#124) --- .../CloudMigrationCoordinator.swift | 5 + .../CloudMigrationViewModel.swift | 4 +- Sources/EditJotPage/EditJotCoordinator.swift | 23 +- .../EditJotViewControllerFactory.swift | 4 +- Sources/EditJotPage/EditJotViewModel.swift | 4 +- .../EnableCloudCoordinator.swift | 8 +- .../EnableCloudViewControllerFactory.swift | 4 +- .../EnableCloudViewModel.swift | 4 +- .../JotConflictCoordinator.swift | 8 +- .../JotConflictViewModel.swift | 4 +- Sources/JotsPage/JotsCoordinator.swift | 39 ++- .../JotsPage/JotsViewControllerFactory.swift | 4 +- Sources/JotsPage/JotsViewModel.swift | 4 +- .../Navigation/NavigationCoordinator.swift | 2 +- .../SettingsPage/SettingsCoordinator.swift | 8 +- .../SettingsViewControllerFactory.swift | 4 +- Sources/SettingsPage/SettingsViewModel.swift | 4 +- .../CloudMigrationCoordinatorTests.swift | 125 +++++++ .../CloudMigrationViewModelTests.swift | 87 +++++ .../EditJotPage/EditJotCoordinatorTests.swift | 293 ++++++++++++++++ .../EditJotPage/EditJotRepositoryTests.swift | 2 +- Tests/EditJotPage/EditJotViewModelTests.swift | 257 ++++++++++++++ .../EnableCloudCoordinatorTests.swift | 103 ++++++ .../EnableCloudViewModelTests.swift | 85 +++++ Tests/Helpers/Navigation+test.swift | 28 ++ Tests/Helpers/UIAlertAction+invoke.swift | 13 + .../JotConflictCoordinatorTests.swift | 112 +++++++ .../JotConflictViewModelTests.swift | 141 ++++++++ .../JotsPage/CreateJotCoordinatorTests.swift | 60 ++++ .../JotsPage/DeleteJotCoordinatorTests.swift | 79 +++++ Tests/JotsPage/JotsCoordinatorTests.swift | 313 ++++++++++++++++++ Tests/JotsPage/JotsViewModelTests.swift | 182 ++++++++++ .../JotsPage/RenameJotCoordinatorTests.swift | 76 +++++ Tests/JotsPage/ShareJotCoordinatorTests.swift | 78 +++++ Tests/JotsPage/ShareJotRepositoryTests.swift | 23 +- .../Mocks/CloudMigrationCoordinatorMock.swift | 40 +++ ...udMigrationViewControllerFactoryMock.swift | 21 ++ Tests/Mocks/CoordinatorFactoryMocks.swift | 153 +++++++++ Tests/Mocks/CoordinatorMock.swift | 19 ++ Tests/Mocks/EditJotCoordinatorMock.swift | 110 ++++++ Tests/Mocks/EditJotRepositoryMock.swift | 57 ++++ .../EditJotViewControllerFactoryMock.swift | 22 ++ Tests/Mocks/EnableCloudCoordinatorMock.swift | 33 ++ ...EnableCloudViewControllerFactoryMock.swift | 21 ++ Tests/Mocks/JotConflictCoordinatorMock.swift | 33 ++ ...JotConflictViewControllerFactoryMock.swift | 21 ++ Tests/Mocks/JotsCoordinatorMock.swift | 82 +++++ .../Mocks/JotsViewControllerFactoryMock.swift | 21 ++ Tests/Mocks/PageCoordinatorFactoryMocks.swift | 95 ++++++ Tests/Mocks/SettingsCoordinatorMock.swift | 35 ++ Tests/Mocks/SettingsRepositoryMock.swift | 41 +++ .../SettingsViewControllerFactoryMock.swift | 21 ++ .../Mocks/SubCoordinatorRepositoryMocks.swift | 82 +++++ Tests/Resources/Calculator Pro.jot | Bin 0 -> 779239 bytes .../RevealFileCoordinatorTests.swift | 55 +++ .../SettingsCoordinatorTests.swift | 108 ++++++ .../SettingsPage/SettingsViewModelTests.swift | 200 +++++++++++ project.yml | 6 +- 58 files changed, 3422 insertions(+), 44 deletions(-) create mode 100644 Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift create mode 100644 Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift create mode 100644 Tests/EditJotPage/EditJotCoordinatorTests.swift create mode 100644 Tests/EditJotPage/EditJotViewModelTests.swift create mode 100644 Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift create mode 100644 Tests/EnableCloudPage/EnableCloudViewModelTests.swift create mode 100644 Tests/Helpers/Navigation+test.swift create mode 100644 Tests/Helpers/UIAlertAction+invoke.swift create mode 100644 Tests/JotConflictPage/JotConflictCoordinatorTests.swift create mode 100644 Tests/JotConflictPage/JotConflictViewModelTests.swift create mode 100644 Tests/JotsPage/CreateJotCoordinatorTests.swift create mode 100644 Tests/JotsPage/DeleteJotCoordinatorTests.swift create mode 100644 Tests/JotsPage/JotsCoordinatorTests.swift create mode 100644 Tests/JotsPage/JotsViewModelTests.swift create mode 100644 Tests/JotsPage/RenameJotCoordinatorTests.swift create mode 100644 Tests/JotsPage/ShareJotCoordinatorTests.swift create mode 100644 Tests/Mocks/CloudMigrationCoordinatorMock.swift create mode 100644 Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift create mode 100644 Tests/Mocks/CoordinatorFactoryMocks.swift create mode 100644 Tests/Mocks/CoordinatorMock.swift create mode 100644 Tests/Mocks/EditJotCoordinatorMock.swift create mode 100644 Tests/Mocks/EditJotRepositoryMock.swift create mode 100644 Tests/Mocks/EditJotViewControllerFactoryMock.swift create mode 100644 Tests/Mocks/EnableCloudCoordinatorMock.swift create mode 100644 Tests/Mocks/EnableCloudViewControllerFactoryMock.swift create mode 100644 Tests/Mocks/JotConflictCoordinatorMock.swift create mode 100644 Tests/Mocks/JotConflictViewControllerFactoryMock.swift create mode 100644 Tests/Mocks/JotsCoordinatorMock.swift create mode 100644 Tests/Mocks/JotsViewControllerFactoryMock.swift create mode 100644 Tests/Mocks/PageCoordinatorFactoryMocks.swift create mode 100644 Tests/Mocks/SettingsCoordinatorMock.swift create mode 100644 Tests/Mocks/SettingsRepositoryMock.swift create mode 100644 Tests/Mocks/SettingsViewControllerFactoryMock.swift create mode 100644 Tests/Mocks/SubCoordinatorRepositoryMocks.swift create mode 100644 Tests/Resources/Calculator Pro.jot create mode 100644 Tests/RevealFile/RevealFileCoordinatorTests.swift create mode 100644 Tests/SettingsPage/SettingsCoordinatorTests.swift create mode 100644 Tests/SettingsPage/SettingsViewModelTests.swift diff --git a/Sources/CloudMigrationPage/CloudMigrationCoordinator.swift b/Sources/CloudMigrationPage/CloudMigrationCoordinator.swift index 2e93e32..d09ac3d 100644 --- a/Sources/CloudMigrationPage/CloudMigrationCoordinator.swift +++ b/Sources/CloudMigrationPage/CloudMigrationCoordinator.swift @@ -18,9 +18,14 @@ import UIKit +@MainActor protocol CloudMigrationCoordinatorProtocol: Coordinator { func shouldStart() -> Bool + + func showInfoAlert(title: String, message: String) + + func dismiss() } final class CloudMigrationCoordinator: CloudMigrationCoordinatorProtocol { diff --git a/Sources/CloudMigrationPage/CloudMigrationViewModel.swift b/Sources/CloudMigrationPage/CloudMigrationViewModel.swift index 3faa04b..080dc0d 100644 --- a/Sources/CloudMigrationPage/CloudMigrationViewModel.swift +++ b/Sources/CloudMigrationPage/CloudMigrationViewModel.swift @@ -25,7 +25,7 @@ final class CloudMigrationViewModel: PageViewModel, Sendable { private let itemsContinuation: AsyncStream<[PageCellItem]>.Continuation private let repository: CloudMigrationRepositoryProtocol - private weak var coordinator: CloudMigrationCoordinator? + private weak var coordinator: CloudMigrationCoordinatorProtocol? private(set) lazy var actions = [ PageCallToActionView.ActionConfiguration( @@ -41,7 +41,7 @@ final class CloudMigrationViewModel: PageViewModel, Sendable { init( repository: CloudMigrationRepositoryProtocol, - coordinator: CloudMigrationCoordinator + coordinator: CloudMigrationCoordinatorProtocol ) { self.repository = repository self.coordinator = coordinator diff --git a/Sources/EditJotPage/EditJotCoordinator.swift b/Sources/EditJotPage/EditJotCoordinator.swift index ac1a917..23e1f0e 100644 --- a/Sources/EditJotPage/EditJotCoordinator.swift +++ b/Sources/EditJotPage/EditJotCoordinator.swift @@ -18,7 +18,28 @@ import UIKit -final class EditJotCoordinator: NavigationCoordinator { +protocol EditJotCoordinatorProtocol: NavigationCoordinator { + + func showShareJot( + jotFileInfo: JotFile.Info, + format: ShareFormat, + configurePopoverAnchor: PopoverAnchor? + ) + func showRenameAlert(jotFileInfo: JotFile.Info) + func openDeleteJot(jotFileInfo: JotFile.Info) + func openJot(jotFileInfo: JotFile.Info) + func showInFiles(jotFileInfo: JotFile.Info) + func showJotConflictPage( + jotFileInfo: JotFile.Info, + jotFileVersions: [JotFileVersion], + onResult: @Sendable @escaping (_ result: JotConflictResult) -> Void + ) + func canGoBack() -> Bool + func goBack() + func showInfoAlert(title: String, message: String) +} + +final class EditJotCoordinator: NavigationCoordinator, EditJotCoordinatorProtocol { private var retainedInfoAlertCoordinator: Coordinator? diff --git a/Sources/EditJotPage/EditJotViewControllerFactory.swift b/Sources/EditJotPage/EditJotViewControllerFactory.swift index d5d55b0..ac63fa6 100644 --- a/Sources/EditJotPage/EditJotViewControllerFactory.swift +++ b/Sources/EditJotPage/EditJotViewControllerFactory.swift @@ -23,7 +23,7 @@ protocol EditJotViewControllerFactoryProtocol: Sendable { func make( jotFileInfo: JotFile.Info, - coordinator: EditJotCoordinator + coordinator: EditJotCoordinatorProtocol ) -> UIViewController } @@ -35,7 +35,7 @@ struct EditJotViewControllerFactory: EditJotViewControllerFactoryProtocol { func make( jotFileInfo: JotFile.Info, - coordinator: EditJotCoordinator, + coordinator: EditJotCoordinatorProtocol, ) -> UIViewController { EditJotViewController( viewModel: EditJotViewModel( diff --git a/Sources/EditJotPage/EditJotViewModel.swift b/Sources/EditJotPage/EditJotViewModel.swift index 3b829af..0aa502d 100644 --- a/Sources/EditJotPage/EditJotViewModel.swift +++ b/Sources/EditJotPage/EditJotViewModel.swift @@ -93,13 +93,13 @@ final class EditJotViewModel: Sendable { private let jotFileInfo: JotFile.Info private let repository: EditJotRepositoryProtocol - private weak var coordinator: EditJotCoordinator? + private weak var coordinator: EditJotCoordinatorProtocol? private let menuConfigurationFactory: JotMenuConfigurationFactory init( jotFileInfo: JotFile.Info, repository: EditJotRepositoryProtocol, - coordinator: EditJotCoordinator, + coordinator: EditJotCoordinatorProtocol, menuConfigurationFactory: JotMenuConfigurationFactory ) { self.jotFileInfo = jotFileInfo diff --git a/Sources/EnableCloudPage/EnableCloudCoordinator.swift b/Sources/EnableCloudPage/EnableCloudCoordinator.swift index 68b2d55..db22edc 100644 --- a/Sources/EnableCloudPage/EnableCloudCoordinator.swift +++ b/Sources/EnableCloudPage/EnableCloudCoordinator.swift @@ -18,7 +18,13 @@ import UIKit -final class EnableCloudCoordinator: Coordinator { +protocol EnableCloudCoordinatorProtocol: Coordinator { + + func openLearnHowToEnable() + func dismiss() +} + +final class EnableCloudCoordinator: Coordinator, EnableCloudCoordinatorProtocol { var onEnd: (() -> Void)? diff --git a/Sources/EnableCloudPage/EnableCloudViewControllerFactory.swift b/Sources/EnableCloudPage/EnableCloudViewControllerFactory.swift index ecb18f2..45cb6c4 100644 --- a/Sources/EnableCloudPage/EnableCloudViewControllerFactory.swift +++ b/Sources/EnableCloudPage/EnableCloudViewControllerFactory.swift @@ -21,7 +21,7 @@ import UIKit @MainActor protocol EnableCloudViewControllerFactoryProtocol: Sendable { - func make(coordinator: EnableCloudCoordinator) -> UIViewController + func make(coordinator: EnableCloudCoordinatorProtocol) -> UIViewController } struct EnableCloudViewControllerFactory: EnableCloudViewControllerFactoryProtocol { @@ -29,7 +29,7 @@ struct EnableCloudViewControllerFactory: EnableCloudViewControllerFactoryProtoco let textBarButtonItemFactory: TextBarButtonItemFactory let symbolBarButtonItemFactory: SymbolBarButtonItemFactory - func make(coordinator: EnableCloudCoordinator) -> UIViewController { + func make(coordinator: EnableCloudCoordinatorProtocol) -> UIViewController { PageViewController( viewModel: EnableCloudViewModel( coordinator: coordinator diff --git a/Sources/EnableCloudPage/EnableCloudViewModel.swift b/Sources/EnableCloudPage/EnableCloudViewModel.swift index fc82312..4786795 100644 --- a/Sources/EnableCloudPage/EnableCloudViewModel.swift +++ b/Sources/EnableCloudPage/EnableCloudViewModel.swift @@ -27,7 +27,7 @@ final class EnableCloudViewModel: PageViewModel, Sendable { let items: AsyncStream<[PageCellItem]> private let itemsContinuation: AsyncStream<[PageCellItem]>.Continuation - private weak var coordinator: EnableCloudCoordinator? + private weak var coordinator: EnableCloudCoordinatorProtocol? private(set) lazy var actions = [ PageCallToActionView.ActionConfiguration( @@ -39,7 +39,7 @@ final class EnableCloudViewModel: PageViewModel, Sendable { } ] - init(coordinator: EnableCloudCoordinator) { + init(coordinator: EnableCloudCoordinatorProtocol) { self.coordinator = coordinator (items, itemsContinuation) = AsyncStream.makeStream( diff --git a/Sources/JotConflictPage/JotConflictCoordinator.swift b/Sources/JotConflictPage/JotConflictCoordinator.swift index 62401bc..eba26aa 100644 --- a/Sources/JotConflictPage/JotConflictCoordinator.swift +++ b/Sources/JotConflictPage/JotConflictCoordinator.swift @@ -18,7 +18,13 @@ import UIKit -final class JotConflictCoordinator: Coordinator { +protocol JotConflictCoordinatorProtocol: Coordinator { + + func showInfoAlert(title: String, message: String) + func dismiss(completion: @Sendable @escaping () -> Void) +} + +final class JotConflictCoordinator: Coordinator, JotConflictCoordinatorProtocol { private var retainedInfoAlertCoordinator: Coordinator? diff --git a/Sources/JotConflictPage/JotConflictViewModel.swift b/Sources/JotConflictPage/JotConflictViewModel.swift index 72c14ea..3eafd83 100644 --- a/Sources/JotConflictPage/JotConflictViewModel.swift +++ b/Sources/JotConflictPage/JotConflictViewModel.swift @@ -85,14 +85,14 @@ final class JotConflictViewModel: PageViewModel, Sendable { private let jotFileInfo: JotFile.Info private let jotFileVersions: [JotFileVersion] private let repository: JotConflictRepositoryProtocol - private weak var coordinator: JotConflictCoordinator? + private weak var coordinator: JotConflictCoordinatorProtocol? private let onResult: @Sendable (_ result: JotConflictResult) -> Void init( jotFileInfo: JotFile.Info, jotFileVersions: [JotFileVersion], repository: JotConflictRepositoryProtocol, - coordinator: JotConflictCoordinator, + coordinator: JotConflictCoordinatorProtocol, onResult: @Sendable @escaping (_ result: JotConflictResult) -> Void ) { assert(jotFileVersions.count >= 1, "Resolving a version conflict between less than two files is not logical.") diff --git a/Sources/JotsPage/JotsCoordinator.swift b/Sources/JotsPage/JotsCoordinator.swift index b3c4877..4c6bbc9 100644 --- a/Sources/JotsPage/JotsCoordinator.swift +++ b/Sources/JotsPage/JotsCoordinator.swift @@ -18,8 +18,25 @@ import UIKit +protocol JotsCoordinatorProtocol: NavigationCoordinator { + + func openSettings() + func openCreateJot() + func openJot(jotFileInfo: JotFile.Info, prefersNewWindow: Bool) + func openEnableCloudPage() + func showShareJot( + jotFileInfo: JotFile.Info, + format: ShareFormat, + configurePopoverAnchor: PopoverAnchor? + ) + func showRenameAlert(jotFileInfo: JotFile.Info) + func openDeleteJot(jotFileInfo: JotFile.Info) + func showInfoAlert(title: String, message: String) + func showInFiles(jotFileInfo: JotFile.Info) +} + @MainActor -final class JotsCoordinator: NavigationCoordinator { +final class JotsCoordinator: NavigationCoordinator, JotsCoordinatorProtocol { private var cloudMigrationTask: Task? @@ -40,11 +57,11 @@ final class JotsCoordinator: NavigationCoordinator { ] private let navigation: Navigation - private let jotsViewControllerFactory: JotsViewControllerFactory - private let settingsCoordinatorFactory: SettingsCoordinatorFactory - private let enableCloudCoordinatorFactory: EnableCloudCoordinatorFactory - private let editJotCoordinatorFactory: EditJotCoordinatorFactory - private let cloudMigrationCoordinatorFactory: CloudMigrationCoordinatorFactory + private let jotsViewControllerFactory: JotsViewControllerFactoryProtocol + private let settingsCoordinatorFactory: SettingsCoordinatorFactoryProtocol + private let enableCloudCoordinatorFactory: EnableCloudCoordinatorFactoryProtocol + private let editJotCoordinatorFactory: EditJotCoordinatorFactoryProtocol + private let cloudMigrationCoordinatorFactory: CloudMigrationCoordinatorFactoryProtocol private let createJotCoordinatorFactory: CreateJotCoordinatorFactoryProtocol private let deleteJotCoordinatorFactory: DeleteJotCoordinatorFactoryProtocol private let renameJotCoordinatorFactory: RenameJotCoordinatorFactoryProtocol @@ -53,11 +70,11 @@ final class JotsCoordinator: NavigationCoordinator { init( navigation: Navigation, - jotsViewControllerFactory: JotsViewControllerFactory, - settingsCoordinatorFactory: SettingsCoordinatorFactory, - enableCloudCoordinatorFactory: EnableCloudCoordinatorFactory, - editJotCoordinatorFactory: EditJotCoordinatorFactory, - cloudMigrationCoordinatorFactory: CloudMigrationCoordinatorFactory, + jotsViewControllerFactory: JotsViewControllerFactoryProtocol, + settingsCoordinatorFactory: SettingsCoordinatorFactoryProtocol, + enableCloudCoordinatorFactory: EnableCloudCoordinatorFactoryProtocol, + editJotCoordinatorFactory: EditJotCoordinatorFactoryProtocol, + cloudMigrationCoordinatorFactory: CloudMigrationCoordinatorFactoryProtocol, createJotCoordinatorFactory: CreateJotCoordinatorFactoryProtocol, deleteJotCoordinatorFactory: DeleteJotCoordinatorFactoryProtocol, renameJotCoordinatorFactory: RenameJotCoordinatorFactoryProtocol, diff --git a/Sources/JotsPage/JotsViewControllerFactory.swift b/Sources/JotsPage/JotsViewControllerFactory.swift index 1f16f61..7a6a5d3 100644 --- a/Sources/JotsPage/JotsViewControllerFactory.swift +++ b/Sources/JotsPage/JotsViewControllerFactory.swift @@ -21,7 +21,7 @@ import UIKit @MainActor protocol JotsViewControllerFactoryProtocol: Sendable { - func make(coordinator: JotsCoordinator) -> UIViewController + func make(coordinator: JotsCoordinatorProtocol) -> UIViewController } struct JotsViewControllerFactory: JotsViewControllerFactoryProtocol { @@ -31,7 +31,7 @@ struct JotsViewControllerFactory: JotsViewControllerFactoryProtocol { let textBarButtonItemFactory: TextBarButtonItemFactory let symbolBarButtonItemFactory: SymbolBarButtonItemFactory - func make(coordinator: JotsCoordinator) -> UIViewController { + func make(coordinator: JotsCoordinatorProtocol) -> UIViewController { let viewController = PageViewController( viewModel: JotsViewModel( coordinator: coordinator, diff --git a/Sources/JotsPage/JotsViewModel.swift b/Sources/JotsPage/JotsViewModel.swift index 42239ed..532fea3 100644 --- a/Sources/JotsPage/JotsViewModel.swift +++ b/Sources/JotsPage/JotsViewModel.swift @@ -42,13 +42,13 @@ final class JotsViewModel: PageViewModel { private var jotsTask: Task? - private weak var coordinator: JotsCoordinator? + private weak var coordinator: JotsCoordinatorProtocol? private let repository: JotsRepositoryProtocol private let menuConfigurationFactory: JotMenuConfigurationFactory init( - coordinator: JotsCoordinator, + coordinator: JotsCoordinatorProtocol, repository: JotsRepositoryProtocol, menuConfigurationFactory: JotMenuConfigurationFactory ) { diff --git a/Sources/Navigation/NavigationCoordinator.swift b/Sources/Navigation/NavigationCoordinator.swift index a0f218f..f6aaa93 100644 --- a/Sources/Navigation/NavigationCoordinator.swift +++ b/Sources/Navigation/NavigationCoordinator.swift @@ -19,7 +19,7 @@ import UIKit @MainActor -protocol NavigationCoordinator: Sendable { +protocol NavigationCoordinator: Sendable, AnyObject { /// Whether this coordinator is capable of navigating to the given ``URL``. func shouldHandle(url: URL) -> Bool diff --git a/Sources/SettingsPage/SettingsCoordinator.swift b/Sources/SettingsPage/SettingsCoordinator.swift index 6e2d42d..8504542 100644 --- a/Sources/SettingsPage/SettingsCoordinator.swift +++ b/Sources/SettingsPage/SettingsCoordinator.swift @@ -18,7 +18,13 @@ import UIKit -final class SettingsCoordinator: Coordinator { +protocol SettingsCoordinatorProtocol: Coordinator { + + func openExternalLink(url: URL) + func dismiss() +} + +final class SettingsCoordinator: Coordinator, SettingsCoordinatorProtocol { var onEnd: (() -> Void)? diff --git a/Sources/SettingsPage/SettingsViewControllerFactory.swift b/Sources/SettingsPage/SettingsViewControllerFactory.swift index 1dc5bfb..d74d7ef 100644 --- a/Sources/SettingsPage/SettingsViewControllerFactory.swift +++ b/Sources/SettingsPage/SettingsViewControllerFactory.swift @@ -21,7 +21,7 @@ import UIKit @MainActor protocol SettingsViewControllerFactoryProtocol: Sendable { - func make(coordinator: SettingsCoordinator) -> UIViewController + func make(coordinator: SettingsCoordinatorProtocol) -> UIViewController } struct SettingsViewControllerFactory: SettingsViewControllerFactoryProtocol { @@ -30,7 +30,7 @@ struct SettingsViewControllerFactory: SettingsViewControllerFactoryProtocol { let textBarButtonItemFactory: TextBarButtonItemFactory let symbolBarButtonItemFactory: SymbolBarButtonItemFactory - func make(coordinator: SettingsCoordinator) -> UIViewController { + func make(coordinator: SettingsCoordinatorProtocol) -> UIViewController { let viewController = PageViewController( viewModel: SettingsViewModel( repository: repository, diff --git a/Sources/SettingsPage/SettingsViewModel.swift b/Sources/SettingsPage/SettingsViewModel.swift index 10fc1ad..77fd30f 100644 --- a/Sources/SettingsPage/SettingsViewModel.swift +++ b/Sources/SettingsPage/SettingsViewModel.swift @@ -37,13 +37,13 @@ final class SettingsViewModel: PageViewModel { private let itemsContinuation: AsyncStream<[PageCellItem]>.Continuation private let repository: SettingsRepositoryProtocol - private weak var coordinator: SettingsCoordinator? + private weak var coordinator: SettingsCoordinatorProtocol? private var loadingTask: Task? init( repository: SettingsRepositoryProtocol, - coordinator: SettingsCoordinator + coordinator: SettingsCoordinatorProtocol ) { self.repository = repository self.coordinator = coordinator diff --git a/Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift b/Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift new file mode 100644 index 0000000..e35a51e --- /dev/null +++ b/Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift @@ -0,0 +1,125 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class CloudMigrationCoordinatorTests: XCTestCase { + + func test_shouldStart_givenRepositoryReturnsTrue_returnsTrue() { + // Given + let coordinator = CloudMigrationCoordinator( + repository: CloudMigrationRepositoryMock(getShouldShowCloudMigrationProvider: { true }), + navigation: Navigation.test(), + cloudMigrationViewControllerFactory: CloudMigrationViewControllerFactoryMock() + ) + + // Then + XCTAssertTrue(coordinator.shouldStart()) + } + + func test_shouldStart_givenRepositoryReturnsFalse_returnsFalse() { + // Given + let coordinator = CloudMigrationCoordinator( + repository: CloudMigrationRepositoryMock(getShouldShowCloudMigrationProvider: { false }), + navigation: Navigation.test(), + cloudMigrationViewControllerFactory: CloudMigrationViewControllerFactoryMock() + ) + + // Then + XCTAssertFalse(coordinator.shouldStart()) + } + + func test_start_givenInvoked_presentsNavigationControllerWithFactoryProducedRoot() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let madeViewController = UIViewController() + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + let navigationController = viewController as? UINavigationController + XCTAssertEqual(navigationController?.viewControllers.first, madeViewController) + presentExpectation.fulfill() + } + } + ) + let coordinator = CloudMigrationCoordinator( + repository: CloudMigrationRepositoryMock(), + navigation: navigation, + cloudMigrationViewControllerFactory: CloudMigrationViewControllerFactoryMock( + makeProvider: { _ in madeViewController } + ) + ) + + // When + coordinator.start() + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + func test_dismiss_givenInvoked_invokesNavigationDismiss() { + // Given + let dismissExpectation = XCTestExpectation(description: "Navigation.dismiss is called.") + let navigation = Navigation.test( + dismissViewControllerProvider: { _, _ in dismissExpectation.fulfill() } + ) + let coordinator = CloudMigrationCoordinator( + repository: CloudMigrationRepositoryMock(), + navigation: navigation, + cloudMigrationViewControllerFactory: CloudMigrationViewControllerFactoryMock() + ) + + // When + coordinator.dismiss() + + // Then + wait(for: [dismissExpectation], timeout: 1) + } + + func test_dismiss_givenCompletion_invokesOnEnd() async { + // Given + let onEndExpectation = XCTestExpectation(description: "CloudMigrationCoordinator.onEnd is called.") + let navigation = Navigation.test( + dismissViewControllerProvider: { _, completion in + completion?() + } + ) + let coordinator = CloudMigrationCoordinator( + repository: CloudMigrationRepositoryMock(), + navigation: navigation, + cloudMigrationViewControllerFactory: CloudMigrationViewControllerFactoryMock() + ) + coordinator.onEnd = { onEndExpectation.fulfill() } + + // When + coordinator.dismiss() + + // Then + await fulfillment(of: [onEndExpectation], timeout: 1) + } + + func test_showInfoAlert_givenInvoked_presentsAlertController() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + XCTAssertTrue(viewController is UIAlertController) + presentExpectation.fulfill() + } + } + ) + let coordinator = CloudMigrationCoordinator( + repository: CloudMigrationRepositoryMock(), + navigation: navigation, + cloudMigrationViewControllerFactory: CloudMigrationViewControllerFactoryMock() + ) + + // When + coordinator.showInfoAlert(title: "title", message: "message") + + // Then + wait(for: [presentExpectation], timeout: 1) + } +} diff --git a/Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift b/Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift new file mode 100644 index 0000000..507f7f3 --- /dev/null +++ b/Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift @@ -0,0 +1,87 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class CloudMigrationViewModelTests: XCTestCase { + + func test_didLoad_givenEmptyJotFiles_yieldsCloudImageAndHeader() async throws { + // Given + let stream = AsyncThrowingStream<[CloudMigrationJotBusinessModel], Error> { continuation in + continuation.yield([]) + continuation.finish() + } + let viewModel = CloudMigrationViewModel( + repository: CloudMigrationRepositoryMock(getJotFilesProvider: { stream }), + coordinator: CloudMigrationCoordinatorMock() + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 2) + } + + func test_didLoad_givenOneJot_yieldsHeaderAndJotItem() async throws { + // Given + let businessModel = CloudMigrationJotBusinessModel( + jotFileInfo: JotFile.Info( + url: URL(staticString: "file:///tmp/foo.jot"), + name: "foo", + modificationDate: Date(timeIntervalSince1970: 0), + ubiquitousInfo: nil + ) + ) + let stream = AsyncThrowingStream<[CloudMigrationJotBusinessModel], Error> { continuation in + continuation.yield([businessModel]) + continuation.finish() + } + let viewModel = CloudMigrationViewModel( + repository: CloudMigrationRepositoryMock(getJotFilesProvider: { stream }), + coordinator: CloudMigrationCoordinatorMock() + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 2) + } + + func test_actions_givenDoneTap_marksDoneAndDismissesViaCoordinator() async { + // Given + let markDoneExpectation = XCTestExpectation(description: "Repository.markCloudMigrationPageDone is called.") + let dismissExpectation = + XCTestExpectation(description: "CloudMigrationCoordinatorMock.dismiss is called.") + let coordinator = CloudMigrationCoordinatorMock( + dismissProvider: { dismissExpectation.fulfill() } + ) + let viewModel = CloudMigrationViewModel( + repository: CloudMigrationRepositoryMock( + markCloudMigrationPageDoneProvider: { markDoneExpectation.fulfill() } + ), + coordinator: coordinator + ) + + // When + XCTAssertEqual(viewModel.actions.count, 1) + viewModel.actions[0].action() + + // Then + await fulfillment(of: [markDoneExpectation, dismissExpectation], timeout: 1) + } +} + +@MainActor +private func firstValue( + of sequence: S +) async throws -> S.Element where S.Element: Sendable { + var iterator = sequence.makeAsyncIterator() + guard let value = try await iterator.next() else { + throw NSError(domain: "CloudMigrationViewModelTests", code: 0) + } + return value +} diff --git a/Tests/EditJotPage/EditJotCoordinatorTests.swift b/Tests/EditJotPage/EditJotCoordinatorTests.swift new file mode 100644 index 0000000..fac8dc7 --- /dev/null +++ b/Tests/EditJotPage/EditJotCoordinatorTests.swift @@ -0,0 +1,293 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class EditJotCoordinatorTests: XCTestCase { + + func test_shouldHandle_givenEditJotURL_returnsTrue() { + // Given + let coordinator = makeCoordinator() + let url = EditJotURL( + jotFileInfo: JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + ).toURL() + + // Then + XCTAssertTrue(coordinator.shouldHandle(url: url)) + } + + func test_shouldHandle_givenNonEditJotURL_returnsFalse() { + // Given + let coordinator = makeCoordinator() + + // Then + XCTAssertFalse(coordinator.shouldHandle(url: URL(staticString: "https://example.com"))) + } + + func test_handle_givenValidURL_returnsViewControllerFromFactory() { + // Given + let madeViewController = UIViewController() + let coordinator = makeCoordinator( + editJotViewControllerFactory: EditJotViewControllerFactoryMock( + makeProvider: { _, _ in madeViewController } + ) + ) + let url = EditJotURL( + jotFileInfo: JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + ).toURL() + + // When + let viewControllers = coordinator.handle(url: url) + + // Then + XCTAssertEqual(viewControllers, [madeViewController]) + } + + func test_handle_givenUnparsableURL_returnsEmpty() { + // Given + let coordinator = makeCoordinator() + + // When + let viewControllers = coordinator.handle(url: URL(staticString: "https://example.com")) + + // Then + XCTAssertTrue(viewControllers.isEmpty) + } + + func test_openJot_givenInvoked_invokesNavigationOpenWithEditJotURL() { + // Given + let openExpectation = XCTestExpectation(description: "Navigation.open is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + openURLProvider: { receivedURL in + XCTAssertEqual(receivedURL, EditJotURL(jotFileInfo: info).toURL()) + openExpectation.fulfill() + } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // When + coordinator.openJot(jotFileInfo: info) + + // Then + wait(for: [openExpectation], timeout: 1) + } + + func test_canGoBack_givenMultipleViewControllers_returnsTrue() { + // Given + let navigation = Navigation.test( + getViewControllersProvider: { [UIViewController(), UIViewController()] } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // Then + XCTAssertTrue(coordinator.canGoBack()) + } + + func test_canGoBack_givenSingleViewController_returnsFalse() { + // Given + let navigation = Navigation.test( + getViewControllersProvider: { [UIViewController()] } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // Then + XCTAssertFalse(coordinator.canGoBack()) + } + + func test_goBack_givenInvoked_invokesNavigationPop() { + // Given + let popExpectation = XCTestExpectation(description: "Navigation.popViewController is called.") + let navigation = Navigation.test( + popViewControllerProvider: { animated in + XCTAssertTrue(animated) + popExpectation.fulfill() + } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // When + coordinator.goBack() + + // Then + wait(for: [popExpectation], timeout: 1) + } + + func test_showShareJot_givenInvoked_startsShareCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "ShareJot Coordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + shareJotCoordinatorFactory: ShareJotCoordinatorFactoryMock( + makeProvider: { _, _, _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.showShareJot(jotFileInfo: info, format: .pdf, configurePopoverAnchor: nil) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_openDeleteJot_givenInvoked_startsDeleteCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "DeleteJot Coordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + deleteJotCoordinatorFactory: DeleteJotCoordinatorFactoryMock( + makeProvider: { _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.openDeleteJot(jotFileInfo: info) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showRenameAlert_givenInvoked_startsRenameCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "RenameJot Coordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + renameJotCoordinatorFactory: RenameJotCoordinatorFactoryMock( + makeProvider: { _, _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.showRenameAlert(jotFileInfo: info) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showInFiles_givenInvoked_startsRevealFileCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "RevealFile Coordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + revealFileCoordinatorFactory: RevealFileCoordinatorFactoryMock( + makeProvider: { _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.showInFiles(jotFileInfo: info) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showJotConflictPage_givenInvoked_startsJotConflictCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "JotConflict Coordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + jotConflictCoordinatorFactory: JotConflictCoordinatorFactoryMock( + makeProvider: { _, _, _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.showJotConflictPage(jotFileInfo: info, jotFileVersions: []) { _ in } + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showInfoAlert_givenInvoked_presentsAlertController() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + XCTAssertTrue(viewController is UIAlertController) + presentExpectation.fulfill() + } + } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // When + coordinator.showInfoAlert(title: "title", message: "message") + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + private func makeCoordinator( + navigation: Navigation = .test(), + repository: EditJotRepositoryProtocol = EditJotRepositoryMock(), + editJotViewControllerFactory: EditJotViewControllerFactoryProtocol = EditJotViewControllerFactoryMock(), + jotConflictCoordinatorFactory: JotConflictCoordinatorFactoryProtocol = JotConflictCoordinatorFactoryMock(), + renameJotCoordinatorFactory: RenameJotCoordinatorFactoryProtocol = RenameJotCoordinatorFactoryMock(), + deleteJotCoordinatorFactory: DeleteJotCoordinatorFactoryProtocol = DeleteJotCoordinatorFactoryMock(), + shareJotCoordinatorFactory: ShareJotCoordinatorFactoryProtocol = ShareJotCoordinatorFactoryMock(), + revealFileCoordinatorFactory: RevealFileCoordinatorFactoryProtocol = RevealFileCoordinatorFactoryMock() + ) -> EditJotCoordinator { + EditJotCoordinator( + navigation: navigation, + repository: repository, + editJotViewControllerFactory: editJotViewControllerFactory, + jotConflictCoordinatorFactory: jotConflictCoordinatorFactory, + renameJotCoordinatorFactory: renameJotCoordinatorFactory, + deleteJotCoordinatorFactory: deleteJotCoordinatorFactory, + shareJotCoordinatorFactory: shareJotCoordinatorFactory, + revealFileCoordinatorFactory: revealFileCoordinatorFactory + ) + } +} diff --git a/Tests/EditJotPage/EditJotRepositoryTests.swift b/Tests/EditJotPage/EditJotRepositoryTests.swift index fb97a3d..b25e38d 100644 --- a/Tests/EditJotPage/EditJotRepositoryTests.swift +++ b/Tests/EditJotPage/EditJotRepositoryTests.swift @@ -55,7 +55,7 @@ final class EditJotRepositoryTests: XCTestCase { // Then XCTAssertEqual(result.width, 800) - XCTAssertEqual(result.drawing.dataRepresentation(), drawingData) + XCTAssertEqual(result.drawing.strokes.count, drawing.strokes.count) } func test_writeDrawing_writesEncodedDrawingViaJotFileService() async throws { diff --git a/Tests/EditJotPage/EditJotViewModelTests.swift b/Tests/EditJotPage/EditJotViewModelTests.swift new file mode 100644 index 0000000..3150dee --- /dev/null +++ b/Tests/EditJotPage/EditJotViewModelTests.swift @@ -0,0 +1,257 @@ +@preconcurrency import PencilKit +import XCTest + +@testable import Jottre + +@MainActor +final class EditJotViewModelTests: XCTestCase { + + func test_didLoad_givenNoConflictingVersions_yieldsDrawingFromRepository() async throws { + // Given + let drawing = PKDrawing() + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock( + readDrawingProvider: { _ in (drawing, 1024) } + ), + coordinator: EditJotCoordinatorMock(), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didLoad() + + // Then + var iterator = viewModel.drawing.makeAsyncIterator() + let nextValue = await iterator.next() + let received = try XCTUnwrap(nextValue) + XCTAssertEqual(received.width, 1024) + } + + func test_didLoad_givenConflictingVersions_invokesShowJotConflictPage() async { + // Given + let conflictExpectation = XCTestExpectation(description: "Coordinator.showJotConflictPage is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = EditJotCoordinatorMock( + showJotConflictPageProvider: { _, _, _ in conflictExpectation.fulfill() } + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock( + getConflictingVersionsProvider: { _ in + [JotFileVersion(localizedNameOfSavingComputer: nil, info: info)] + } + ), + coordinator: coordinator, + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didLoad() + + // Then + await fulfillment(of: [conflictExpectation], timeout: 1) + } + + func test_didTapBackButton_givenNoConflicts_invokesGoBack() async { + // Given + let goBackExpectation = XCTestExpectation(description: "Coordinator.goBack is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = EditJotCoordinatorMock( + goBackProvider: { goBackExpectation.fulfill() } + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock(), + coordinator: coordinator, + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didTapBackButton() + + // Then + await fulfillment(of: [goBackExpectation], timeout: 1) + } + + func test_didTapBackButton_givenConflicts_invokesShowJotConflictPage() async { + // Given + let conflictExpectation = XCTestExpectation(description: "Coordinator.showJotConflictPage is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = EditJotCoordinatorMock( + showJotConflictPageProvider: { _, _, _ in conflictExpectation.fulfill() } + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock( + getConflictingVersionsProvider: { _ in + [JotFileVersion(localizedNameOfSavingComputer: nil, info: info)] + } + ), + coordinator: coordinator, + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didTapBackButton() + + // Then + await fulfillment(of: [conflictExpectation], timeout: 1) + } + + func test_showsBackButton_givenDidLoadAndCanGoBack_yieldsTrue() async throws { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = EditJotCoordinatorMock( + canGoBackProvider: { true } + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock(), + coordinator: coordinator, + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didLoad() + var iterator = viewModel.showsBackButton.makeAsyncIterator() + let nextValue = await iterator.next() + let value = try XCTUnwrap(nextValue) + + // Then + XCTAssertTrue(value) + } + + func test_didTapToggleEditingButton_givenFalse_yieldsTrue() async throws { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock(), + coordinator: EditJotCoordinatorMock(), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didTapToggleEditingButton(isEditing: false) + + // Then + var iterator = viewModel.isEditing.makeAsyncIterator() + let nextValue = await iterator.next() + let firstValue = try XCTUnwrap(nextValue) + let value = try XCTUnwrap(firstValue) + XCTAssertTrue(value) + } + + func test_menuConfigurations_givenDuplicateActionThrows_invokesShowInfoAlert() async { + // Given + let alertExpectation = XCTestExpectation(description: "Coordinator.showInfoAlert is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = EditJotCoordinatorMock( + showInfoAlertProvider: { _, _ in alertExpectation.fulfill() } + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock( + duplicateProvider: { _ in throw NSError(domain: "test", code: 0) } + ), + coordinator: coordinator, + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When (find duplicate action and invoke) + let configurations = viewModel.menuConfigurations.make(popoverAnchorProvider: { nil }) + let duplicateAction = configurations.compactMap { configuration -> JotMenuConfiguration.Action? in + if case let .action(action) = configuration, action.systemImageName == "plus.square.on.square" { + return action + } + return nil + }.first + try? XCTUnwrap(duplicateAction).handler() + await Task.yield() + + // Then + await fulfillment(of: [alertExpectation], timeout: 1) + } + + func test_menuConfigurations_givenDuplicateActionSucceeds_invokesOpenJot() async { + // Given + let openJotExpectation = XCTestExpectation(description: "Coordinator.openJot is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let duplicatedInfo = JotFile.Info( + url: URL(staticString: "file:///tmp/note 1.jot"), + name: "note 1", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = EditJotCoordinatorMock( + openJotProvider: { received in + XCTAssertEqual(received, duplicatedInfo) + openJotExpectation.fulfill() + } + ) + let viewModel = EditJotViewModel( + jotFileInfo: info, + repository: EditJotRepositoryMock( + duplicateProvider: { _ in duplicatedInfo } + ), + coordinator: coordinator, + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + let configurations = viewModel.menuConfigurations.make(popoverAnchorProvider: { nil }) + let duplicateAction = configurations.compactMap { configuration -> JotMenuConfiguration.Action? in + if case let .action(action) = configuration, action.systemImageName == "plus.square.on.square" { + return action + } + return nil + }.first + try? XCTUnwrap(duplicateAction).handler() + await Task.yield() + + // Then + await fulfillment(of: [openJotExpectation], timeout: 1) + } +} diff --git a/Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift b/Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift new file mode 100644 index 0000000..666edc5 --- /dev/null +++ b/Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift @@ -0,0 +1,103 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class EnableCloudCoordinatorTests: XCTestCase { + + func test_start_givenInvoked_presentsNavigationControllerWithFactoryProducedRoot() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let madeViewController = UIViewController() + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, animated in + MainActor.assumeIsolated { + // Then + XCTAssertTrue(viewController is UINavigationController) + let navigationController = viewController as? UINavigationController + XCTAssertEqual(navigationController?.viewControllers.first, madeViewController) + XCTAssertTrue(animated) + presentExpectation.fulfill() + } + } + ) + let coordinator = EnableCloudCoordinator( + navigation: navigation, + enableCloudViewControllerFactory: EnableCloudViewControllerFactoryMock( + makeProvider: { _ in madeViewController } + ) + ) + + // When + coordinator.start() + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + func test_openLearnHowToEnable_givenInvoked_invokesNavigationOpenExternalWithSupportURL() { + // Given + let openExpectation = XCTestExpectation(description: "Navigation.openExternal is called.") + let navigation = Navigation.test( + openExternalURLProvider: { receivedURL in + // Then + XCTAssertEqual(receivedURL, EnableICloudSupportURL().toURL()) + openExpectation.fulfill() + } + ) + let coordinator = EnableCloudCoordinator( + navigation: navigation, + enableCloudViewControllerFactory: EnableCloudViewControllerFactoryMock() + ) + + // When + coordinator.openLearnHowToEnable() + + // Then + wait(for: [openExpectation], timeout: 1) + } + + func test_dismiss_givenInvoked_invokesNavigationDismissAnimated() { + // Given + let dismissExpectation = XCTestExpectation(description: "Navigation.dismiss is called.") + let navigation = Navigation.test( + dismissViewControllerProvider: { animated, _ in + // Then + XCTAssertTrue(animated) + dismissExpectation.fulfill() + } + ) + let coordinator = EnableCloudCoordinator( + navigation: navigation, + enableCloudViewControllerFactory: EnableCloudViewControllerFactoryMock() + ) + + // When + coordinator.dismiss() + + // Then + wait(for: [dismissExpectation], timeout: 1) + } + + func test_dismiss_givenCompletion_invokesOnEnd() async { + // Given + let onEndExpectation = XCTestExpectation(description: "EnableCloudCoordinator.onEnd is called.") + let navigation = Navigation.test( + dismissViewControllerProvider: { _, completion in + completion?() + } + ) + let coordinator = EnableCloudCoordinator( + navigation: navigation, + enableCloudViewControllerFactory: EnableCloudViewControllerFactoryMock() + ) + coordinator.onEnd = { onEndExpectation.fulfill() } + + // When + coordinator.dismiss() + + // Then + await fulfillment(of: [onEndExpectation], timeout: 1) + } +} diff --git a/Tests/EnableCloudPage/EnableCloudViewModelTests.swift b/Tests/EnableCloudPage/EnableCloudViewModelTests.swift new file mode 100644 index 0000000..8fca48d --- /dev/null +++ b/Tests/EnableCloudPage/EnableCloudViewModelTests.swift @@ -0,0 +1,85 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class EnableCloudViewModelTests: XCTestCase { + + func test_items_givenInit_yieldsHeaderAndTwoFeatureRows() async throws { + // Given + let viewModel = EnableCloudViewModel(coordinator: EnableCloudCoordinatorMock()) + + // When + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 3) + } + + func test_rightNavigationItems_givenInit_yieldsXmarkSymbol() async throws { + // Given + let viewModel = EnableCloudViewModel(coordinator: EnableCloudCoordinatorMock()) + + // When + let items = try await firstValue(of: viewModel.rightNavigationItems) + + // Then + XCTAssertEqual(items.count, 1) + guard case let .symbol(systemImageName, _) = items[0] else { + XCTFail("Expected .symbol") + return + } + XCTAssertEqual(systemImageName, "xmark") + } + + func test_rightNavigationItem_givenTap_invokesCoordinatorDismiss() async throws { + // Given + let dismissExpectation = XCTestExpectation(description: "EnableCloudCoordinatorMock.dismiss is called.") + let coordinator = EnableCloudCoordinatorMock( + dismissProvider: { dismissExpectation.fulfill() } + ) + let viewModel = EnableCloudViewModel(coordinator: coordinator) + + // When + let items = try await firstValue(of: viewModel.rightNavigationItems) + guard case let .symbol(_, onAction) = items[0] else { + XCTFail("Expected .symbol") + return + } + onAction() + await Task.yield() + + // Then + await fulfillment(of: [dismissExpectation], timeout: 1) + } + + func test_actions_givenLearnHowToEnableTap_invokesCoordinatorOpenLearnHowToEnable() async throws { + // Given + let openExpectation = XCTestExpectation( + description: "EnableCloudCoordinatorMock.openLearnHowToEnable is called." + ) + let coordinator = EnableCloudCoordinatorMock( + openLearnHowToEnableProvider: { openExpectation.fulfill() } + ) + let viewModel = EnableCloudViewModel(coordinator: coordinator) + + // When + XCTAssertEqual(viewModel.actions.count, 1) + viewModel.actions[0].action() + await Task.yield() + + // Then + await fulfillment(of: [openExpectation], timeout: 1) + } +} + +@MainActor +private func firstValue( + of sequence: S +) async throws -> S.Element where S.Element: Sendable { + var iterator = sequence.makeAsyncIterator() + guard let value = try await iterator.next() else { + throw NSError(domain: "EnableCloudViewModelTests", code: 0) + } + return value +} diff --git a/Tests/Helpers/Navigation+test.swift b/Tests/Helpers/Navigation+test.swift new file mode 100644 index 0000000..608e8f7 --- /dev/null +++ b/Tests/Helpers/Navigation+test.swift @@ -0,0 +1,28 @@ +import UIKit + +@testable import Jottre + +extension Navigation { + + static func test( + openURLProvider: @Sendable @escaping (_ url: URL) -> Void = { _ in }, + openExternalURLProvider: @Sendable @escaping (_ url: URL) -> Void = { _ in }, + openSceneProvider: @Sendable @escaping (_ url: URL) -> Void = { _ in }, + presentViewControllerProvider: + @Sendable @escaping (_ viewController: UIViewController, _ animated: Bool) -> Void = { _, _ in }, + dismissViewControllerProvider: + @Sendable @escaping (_ animated: Bool, _ completion: (@Sendable () -> Void)?) -> Void = { _, _ in }, + popViewControllerProvider: @Sendable @escaping (_ animated: Bool) -> Void = { _ in }, + getViewControllersProvider: @MainActor @escaping () -> [UIViewController] = { [] } + ) -> Navigation { + Navigation( + openURLProvider: openURLProvider, + openExternalURLProvider: openExternalURLProvider, + openSceneProvider: openSceneProvider, + presentViewControllerProvider: presentViewControllerProvider, + dismissViewControllerProvider: dismissViewControllerProvider, + popViewControllerProvider: popViewControllerProvider, + getViewControllersProvider: getViewControllersProvider + ) + } +} diff --git a/Tests/Helpers/UIAlertAction+invoke.swift b/Tests/Helpers/UIAlertAction+invoke.swift new file mode 100644 index 0000000..5239c73 --- /dev/null +++ b/Tests/Helpers/UIAlertAction+invoke.swift @@ -0,0 +1,13 @@ +import UIKit + +extension UIAlertAction { + + func invokeHandler() { + typealias Handler = @convention(block) (UIAlertAction) -> Void + guard let block = value(forKey: "handler") else { + return + } + let handler = unsafeBitCast(block as AnyObject, to: Handler.self) + handler(self) + } +} diff --git a/Tests/JotConflictPage/JotConflictCoordinatorTests.swift b/Tests/JotConflictPage/JotConflictCoordinatorTests.swift new file mode 100644 index 0000000..8eb021a --- /dev/null +++ b/Tests/JotConflictPage/JotConflictCoordinatorTests.swift @@ -0,0 +1,112 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class JotConflictCoordinatorTests: XCTestCase { + + func test_start_givenInvoked_presentsModalNavigationController() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let madeViewController = UIViewController() + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + let navigationController = viewController as? UINavigationController + XCTAssertEqual(navigationController?.viewControllers.first, madeViewController) + XCTAssertTrue(madeViewController.isModalInPresentation) + XCTAssertFalse(navigationController?.navigationBar.prefersLargeTitles ?? true) + presentExpectation.fulfill() + } + } + ) + let coordinator = JotConflictCoordinator( + jotFileInfo: info, + jotFileVersions: [JotFileVersion(localizedNameOfSavingComputer: "Mac", info: info)], + repository: JotConflictRepositoryMock(), + navigation: navigation, + jotConflictViewControllerFactory: JotConflictViewControllerFactoryMock( + makeProvider: { _ in madeViewController } + ), + onResult: { _ in } + ) + + // When + coordinator.start() + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + func test_dismiss_givenCompletion_invokesNavigationDismissAndOnEnd() async { + // Given + let completionExpectation = XCTestExpectation(description: "Completion is invoked.") + let onEndExpectation = XCTestExpectation(description: "JotConflictCoordinator.onEnd is invoked.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + dismissViewControllerProvider: { _, completion in + completion?() + } + ) + let coordinator = JotConflictCoordinator( + jotFileInfo: info, + jotFileVersions: [], + repository: JotConflictRepositoryMock(), + navigation: navigation, + jotConflictViewControllerFactory: JotConflictViewControllerFactoryMock(), + onResult: { _ in } + ) + coordinator.onEnd = { onEndExpectation.fulfill() } + + // When + coordinator.dismiss(completion: { completionExpectation.fulfill() }) + + // Then + await fulfillment(of: [completionExpectation, onEndExpectation], timeout: 1) + } + + func test_showInfoAlert_givenInvoked_presentsAlertController() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + XCTAssertTrue(viewController is UIAlertController) + presentExpectation.fulfill() + } + } + ) + let coordinator = JotConflictCoordinator( + jotFileInfo: info, + jotFileVersions: [], + repository: JotConflictRepositoryMock(), + navigation: navigation, + jotConflictViewControllerFactory: JotConflictViewControllerFactoryMock(), + onResult: { _ in } + ) + + // When + coordinator.showInfoAlert(title: "title", message: "message") + + // Then + wait(for: [presentExpectation], timeout: 1) + } +} diff --git a/Tests/JotConflictPage/JotConflictViewModelTests.swift b/Tests/JotConflictPage/JotConflictViewModelTests.swift new file mode 100644 index 0000000..1fc865d --- /dev/null +++ b/Tests/JotConflictPage/JotConflictViewModelTests.swift @@ -0,0 +1,141 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class JotConflictViewModelTests: XCTestCase { + + func test_items_givenOneVersion_yieldsHeaderAndDeviceVersionAndProvidedVersion() async throws { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let version = JotFileVersion(localizedNameOfSavingComputer: "Mac", info: info) + let viewModel = JotConflictViewModel( + jotFileInfo: info, + jotFileVersions: [version], + repository: JotConflictRepositoryMock(), + coordinator: JotConflictCoordinatorMock(), + onResult: { _ in } + ) + + // When + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 3) + } + + func test_actions_givenTwoVersions_yieldsThreeActions() { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let viewModel = JotConflictViewModel( + jotFileInfo: info, + jotFileVersions: [ + JotFileVersion(localizedNameOfSavingComputer: "Mac", info: info), + JotFileVersion(localizedNameOfSavingComputer: "iPad", info: info), + ], + repository: JotConflictRepositoryMock(), + coordinator: JotConflictCoordinatorMock(), + onResult: { _ in } + ) + + // Then: 1 device version + 2 provided versions + keep-all = 4 + XCTAssertEqual(viewModel.actions.count, 4) + } + + func test_actions_givenKeepAllTap_resolvesAllAndDismissesWithKeepAllResult() { + // Given + let resolveExpectation = XCTestExpectation(description: "Repository.resolveVersionConflicts is called.") + let dismissExpectation = XCTestExpectation(description: "Coordinator.dismiss is called.") + let onResultExpectation = XCTestExpectation(description: "onResult is called with .keepAll.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = JotConflictCoordinatorMock( + dismissProvider: { completion in + dismissExpectation.fulfill() + completion() + } + ) + let viewModel = JotConflictViewModel( + jotFileInfo: info, + jotFileVersions: [ + JotFileVersion(localizedNameOfSavingComputer: "Mac", info: info) + ], + repository: JotConflictRepositoryMock( + resolveVersionConflictsProvider: { _, resolved in + XCTAssertEqual(resolved.count, 2) + resolveExpectation.fulfill() + } + ), + coordinator: coordinator, + onResult: { result in + if case .keepAll = result { + onResultExpectation.fulfill() + } + } + ) + + // When (last action is keepAll) + viewModel.actions.last?.action() + + // Then + wait(for: [resolveExpectation, dismissExpectation, onResultExpectation], timeout: 1) + } + + func test_actions_givenKeepVersionThrows_invokesShowInfoAlert() async { + // Given + let alertExpectation = XCTestExpectation(description: "Coordinator.showInfoAlert is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = JotConflictCoordinatorMock( + showInfoAlertProvider: { _, _ in alertExpectation.fulfill() } + ) + let viewModel = JotConflictViewModel( + jotFileInfo: info, + jotFileVersions: [ + JotFileVersion(localizedNameOfSavingComputer: "Mac", info: info) + ], + repository: JotConflictRepositoryMock( + resolveVersionConflictsProvider: { _, _ in + throw NSError(domain: "test", code: 0) + } + ), + coordinator: coordinator, + onResult: { _ in } + ) + + // When (first action is keep version) + viewModel.actions.first?.action() + + // Then + await fulfillment(of: [alertExpectation], timeout: 1) + } +} + +@MainActor +private func firstValue( + of sequence: S +) async throws -> S.Element where S.Element: Sendable { + var iterator = sequence.makeAsyncIterator() + guard let value = try await iterator.next() else { + throw NSError(domain: "JotConflictViewModelTests", code: 0) + } + return value +} diff --git a/Tests/JotsPage/CreateJotCoordinatorTests.swift b/Tests/JotsPage/CreateJotCoordinatorTests.swift new file mode 100644 index 0000000..59f21ce --- /dev/null +++ b/Tests/JotsPage/CreateJotCoordinatorTests.swift @@ -0,0 +1,60 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class CreateJotCoordinatorTests: XCTestCase { + + func test_start_givenInvoked_presentsAlertWithTitleAndCreateAndCancelActions() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + let alert = viewController as? UIAlertController + XCTAssertNotNil(alert) + XCTAssertEqual(alert?.actions.count, 2) + XCTAssertEqual(alert?.actions.last?.style, .cancel) + presentExpectation.fulfill() + } + } + ) + let coordinator = CreateJotCoordinator( + navigation: navigation, + repository: CreateJotRepositoryMock() + ) + + // When + coordinator.start() + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + func test_start_givenCancelTapped_invokesOnEnd() { + // Given + let onEndExpectation = XCTestExpectation(description: "CreateJotCoordinator.onEnd is invoked.") + var alertController: UIAlertController? + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + alertController = viewController as? UIAlertController + } + } + ) + let coordinator = CreateJotCoordinator( + navigation: navigation, + repository: CreateJotRepositoryMock() + ) + coordinator.onEnd = { onEndExpectation.fulfill() } + + // When + coordinator.start() + let cancelAction = alertController?.actions.first { $0.style == .cancel } + cancelAction?.invokeHandler() + + // Then + wait(for: [onEndExpectation], timeout: 1) + } +} diff --git a/Tests/JotsPage/DeleteJotCoordinatorTests.swift b/Tests/JotsPage/DeleteJotCoordinatorTests.swift new file mode 100644 index 0000000..ff9bf0a --- /dev/null +++ b/Tests/JotsPage/DeleteJotCoordinatorTests.swift @@ -0,0 +1,79 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class DeleteJotCoordinatorTests: XCTestCase { + + func test_start_givenInvoked_presentsAlertWithDestructiveDeleteAction() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + let alert = viewController as? UIAlertController + XCTAssertNotNil(alert) + XCTAssertEqual(alert?.actions.count, 2) + XCTAssertEqual(alert?.actions.last?.style, .destructive) + presentExpectation.fulfill() + } + } + ) + let coordinator = DeleteJotCoordinator( + jotFileInfo: info, + navigation: navigation, + repository: DeleteJotRepositoryMock() + ) + + // When + coordinator.start() + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + func test_start_givenDeleteActionTapped_invokesRepositoryDeleteAndDismisses() { + // Given + let deleteExpectation = XCTestExpectation(description: "Repository.deleteJot is called.") + let dismissExpectation = XCTestExpectation(description: "Navigation.dismiss is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + var alertController: UIAlertController? + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + alertController = viewController as? UIAlertController + } + }, + dismissViewControllerProvider: { _, _ in + dismissExpectation.fulfill() + } + ) + let coordinator = DeleteJotCoordinator( + jotFileInfo: info, + navigation: navigation, + repository: DeleteJotRepositoryMock( + deleteJotProvider: { _ in deleteExpectation.fulfill() } + ) + ) + + // When + coordinator.start() + let destructive = alertController?.actions.first { $0.style == .destructive } + destructive?.invokeHandler() + + // Then + wait(for: [deleteExpectation, dismissExpectation], timeout: 1) + } +} diff --git a/Tests/JotsPage/JotsCoordinatorTests.swift b/Tests/JotsPage/JotsCoordinatorTests.swift new file mode 100644 index 0000000..bdac0d9 --- /dev/null +++ b/Tests/JotsPage/JotsCoordinatorTests.swift @@ -0,0 +1,313 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class JotsCoordinatorTests: XCTestCase { + + func test_shouldHandle_givenAnyURL_returnsTrue() { + // Given + let coordinator = makeCoordinator() + + // Then + XCTAssertTrue(coordinator.shouldHandle(url: URL(staticString: "https://example.com"))) + } + + func test_handle_givenNonEditJotURL_returnsCachedJotsViewController() { + // Given + let madeViewController = UIViewController() + let coordinator = makeCoordinator( + jotsViewControllerFactory: JotsViewControllerFactoryMock( + makeProvider: { _ in madeViewController } + ) + ) + + // When + let viewControllers = coordinator.handle(url: URL(staticString: "https://example.com")) + + // Then + XCTAssertEqual(viewControllers, [madeViewController]) + } + + func test_handle_givenEditJotURL_returnsJotsAndChildViewControllers() { + // Given + let madeViewController = UIViewController() + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let editJotURL = EditJotURL(jotFileInfo: info).toURL() + let editJotViewController = UIViewController() + let coordinator = makeCoordinator( + jotsViewControllerFactory: JotsViewControllerFactoryMock( + makeProvider: { _ in madeViewController } + ), + editJotCoordinatorFactory: EditJotCoordinatorFactoryMock( + makeProvider: { _ in + NavigationCoordinatorMock( + shouldHandleProvider: { _ in true }, + handleProvider: { _ in [editJotViewController] } + ) + } + ) + ) + + // When + let viewControllers = coordinator.handle(url: editJotURL) + + // Then + XCTAssertEqual(viewControllers, [madeViewController, editJotViewController]) + } + + func test_openSettings_givenInvoked_startsSettingsCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "SettingsCoordinator.start is called.") + let coordinator = makeCoordinator( + settingsCoordinatorFactory: SettingsCoordinatorFactoryMock( + makeProvider: { _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.openSettings() + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_openCreateJot_givenInvoked_startsCreateJotCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "CreateJotCoordinator.start is called.") + let coordinator = makeCoordinator( + createJotCoordinatorFactory: CreateJotCoordinatorFactoryMock( + makeProvider: { _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.openCreateJot() + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_openEnableCloudPage_givenInvoked_startsEnableCloudCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "EnableCloudCoordinator.start is called.") + let coordinator = makeCoordinator( + enableCloudCoordinatorFactory: EnableCloudCoordinatorFactoryMock( + makeProvider: { _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.openEnableCloudPage() + + // Then + wait(for: [startExpectation], timeout: 1) + } + + #if !targetEnvironment(macCatalyst) + func test_openJot_givenPrefersNewWindow_invokesNavigationOpenScene() { + // Given + let openSceneExpectation = XCTestExpectation(description: "Navigation.openScene is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + openSceneProvider: { receivedURL in + XCTAssertEqual(receivedURL, EditJotURL(jotFileInfo: info).toURL()) + openSceneExpectation.fulfill() + } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // When + coordinator.openJot(jotFileInfo: info, prefersNewWindow: true) + + // Then + wait(for: [openSceneExpectation], timeout: 1) + } + + func test_openJot_givenPrefersSameWindow_invokesNavigationOpen() { + // Given + let openExpectation = XCTestExpectation(description: "Navigation.open is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + openURLProvider: { receivedURL in + XCTAssertEqual(receivedURL, EditJotURL(jotFileInfo: info).toURL()) + openExpectation.fulfill() + } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // When + coordinator.openJot(jotFileInfo: info, prefersNewWindow: false) + + // Then + wait(for: [openExpectation], timeout: 1) + } + #endif + + func test_openDeleteJot_givenInvoked_startsDeleteJotCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "DeleteJotCoordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + deleteJotCoordinatorFactory: DeleteJotCoordinatorFactoryMock( + makeProvider: { _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.openDeleteJot(jotFileInfo: info) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showRenameAlert_givenInvoked_startsRenameJotCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "RenameJotCoordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + renameJotCoordinatorFactory: RenameJotCoordinatorFactoryMock( + makeProvider: { _, _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.showRenameAlert(jotFileInfo: info) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showShareJot_givenInvoked_startsShareJotCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "ShareJotCoordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + shareJotCoordinatorFactory: ShareJotCoordinatorFactoryMock( + makeProvider: { _, _, _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.showShareJot(jotFileInfo: info, format: .pdf, configurePopoverAnchor: nil) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showInFiles_givenInvoked_startsRevealFileCoordinator() { + // Given + let startExpectation = XCTestExpectation(description: "RevealFileCoordinator.start is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let coordinator = makeCoordinator( + revealFileCoordinatorFactory: RevealFileCoordinatorFactoryMock( + makeProvider: { _, _ in + CoordinatorMock(startProvider: { startExpectation.fulfill() }) + } + ) + ) + + // When + coordinator.showInFiles(jotFileInfo: info) + + // Then + wait(for: [startExpectation], timeout: 1) + } + + func test_showInfoAlert_givenInvoked_presentsAlertController() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + XCTAssertTrue(viewController is UIAlertController) + presentExpectation.fulfill() + } + } + ) + let coordinator = makeCoordinator(navigation: navigation) + + // When + coordinator.showInfoAlert(title: "title", message: "message") + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + private func makeCoordinator( + navigation: Navigation = .test(), + jotsViewControllerFactory: JotsViewControllerFactoryProtocol = JotsViewControllerFactoryMock(), + settingsCoordinatorFactory: SettingsCoordinatorFactoryProtocol = SettingsCoordinatorFactoryMock(), + enableCloudCoordinatorFactory: EnableCloudCoordinatorFactoryProtocol = EnableCloudCoordinatorFactoryMock(), + editJotCoordinatorFactory: EditJotCoordinatorFactoryProtocol = EditJotCoordinatorFactoryMock(), + cloudMigrationCoordinatorFactory: CloudMigrationCoordinatorFactoryProtocol = + CloudMigrationCoordinatorFactoryMock(), + createJotCoordinatorFactory: CreateJotCoordinatorFactoryProtocol = CreateJotCoordinatorFactoryMock(), + deleteJotCoordinatorFactory: DeleteJotCoordinatorFactoryProtocol = DeleteJotCoordinatorFactoryMock(), + renameJotCoordinatorFactory: RenameJotCoordinatorFactoryProtocol = RenameJotCoordinatorFactoryMock(), + shareJotCoordinatorFactory: ShareJotCoordinatorFactoryProtocol = ShareJotCoordinatorFactoryMock(), + revealFileCoordinatorFactory: RevealFileCoordinatorFactoryProtocol = RevealFileCoordinatorFactoryMock() + ) -> JotsCoordinator { + JotsCoordinator( + navigation: navigation, + jotsViewControllerFactory: jotsViewControllerFactory, + settingsCoordinatorFactory: settingsCoordinatorFactory, + enableCloudCoordinatorFactory: enableCloudCoordinatorFactory, + editJotCoordinatorFactory: editJotCoordinatorFactory, + cloudMigrationCoordinatorFactory: cloudMigrationCoordinatorFactory, + createJotCoordinatorFactory: createJotCoordinatorFactory, + deleteJotCoordinatorFactory: deleteJotCoordinatorFactory, + renameJotCoordinatorFactory: renameJotCoordinatorFactory, + shareJotCoordinatorFactory: shareJotCoordinatorFactory, + revealFileCoordinatorFactory: revealFileCoordinatorFactory + ) + } +} diff --git a/Tests/JotsPage/JotsViewModelTests.swift b/Tests/JotsPage/JotsViewModelTests.swift new file mode 100644 index 0000000..5fb28b5 --- /dev/null +++ b/Tests/JotsPage/JotsViewModelTests.swift @@ -0,0 +1,182 @@ +import XCTest + +@testable import Jottre + +@MainActor +final class JotsViewModelTests: XCTestCase { + + func test_leftNavigationItems_givenShouldNotShowICloudButton_yieldsOnlySettings() async throws { + // Given + let viewModel = JotsViewModel( + coordinator: JotsCoordinatorMock(), + repository: JotsRepositoryMock(shouldShowEnableICloudButtonProvider: { false }), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + let items = try await firstValue(of: viewModel.leftNavigationItems) + + // Then + XCTAssertEqual(items.count, 1) + guard case let .symbol(systemImageName, _) = items[0] else { + XCTFail("Expected .symbol") + return + } + XCTAssertEqual(systemImageName, "gear") + } + + func test_leftNavigationItems_givenShouldShowICloudButton_yieldsSettingsAndICloudSlash() async throws { + // Given + let viewModel = JotsViewModel( + coordinator: JotsCoordinatorMock(), + repository: JotsRepositoryMock(shouldShowEnableICloudButtonProvider: { true }), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + let items = try await firstValue(of: viewModel.leftNavigationItems) + + // Then + XCTAssertEqual(items.count, 2) + guard case let .symbol(secondImage, _) = items[1] else { + XCTFail("Expected .symbol") + return + } + XCTAssertEqual(secondImage, "icloud.slash") + } + + func test_leftNavigationItem_givenSettingsTap_invokesOpenSettings() async throws { + // Given + let openSettingsExpectation = XCTestExpectation(description: "Coordinator.openSettings is called.") + let coordinator = JotsCoordinatorMock( + openSettingsProvider: { openSettingsExpectation.fulfill() } + ) + let viewModel = JotsViewModel( + coordinator: coordinator, + repository: JotsRepositoryMock(), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + let items = try await firstValue(of: viewModel.leftNavigationItems) + guard case let .symbol(_, onAction) = items[0] else { + XCTFail("Expected .symbol") + return + } + onAction() + await Task.yield() + + // Then + await fulfillment(of: [openSettingsExpectation], timeout: 1) + } + + func test_leftNavigationItem_givenICloudTap_invokesOpenEnableCloudPage() async throws { + // Given + let expectation = XCTestExpectation(description: "Coordinator.openEnableCloudPage is called.") + let coordinator = JotsCoordinatorMock( + openEnableCloudPageProvider: { expectation.fulfill() } + ) + let viewModel = JotsViewModel( + coordinator: coordinator, + repository: JotsRepositoryMock(shouldShowEnableICloudButtonProvider: { true }), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + let items = try await firstValue(of: viewModel.leftNavigationItems) + guard case let .symbol(_, onAction) = items[1] else { + XCTFail("Expected .symbol") + return + } + onAction() + await Task.yield() + + // Then + await fulfillment(of: [expectation], timeout: 1) + } + + #if !targetEnvironment(macCatalyst) + func test_rightNavigationItem_givenCreateTap_invokesOpenCreateJot() async throws { + // Given + let expectation = XCTestExpectation(description: "Coordinator.openCreateJot is called.") + let coordinator = JotsCoordinatorMock( + openCreateJotProvider: { expectation.fulfill() } + ) + let viewModel = JotsViewModel( + coordinator: coordinator, + repository: JotsRepositoryMock(), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + let items = try await firstValue(of: viewModel.rightNavigationItems) + XCTAssertEqual(items.count, 1) + guard case let .text(_, onAction) = items[0] else { + XCTFail("Expected .text") + return + } + onAction() + await Task.yield() + + // Then + await fulfillment(of: [expectation], timeout: 1) + } + #endif + + func test_didLoad_givenEmptyJots_yieldsEmptyStateItem() async throws { + // Given + let stream = AsyncThrowingStream<[JotFile.Info], Error> { continuation in + continuation.yield([]) + continuation.finish() + } + let viewModel = JotsViewModel( + coordinator: JotsCoordinatorMock(), + repository: JotsRepositoryMock(getJotFilesProvider: { stream }), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 1) + } + + func test_didLoad_givenOneJot_yieldsOneJotItem() async throws { + // Given + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let stream = AsyncThrowingStream<[JotFile.Info], Error> { continuation in + continuation.yield([info]) + continuation.finish() + } + let viewModel = JotsViewModel( + coordinator: JotsCoordinatorMock(), + repository: JotsRepositoryMock(getJotFilesProvider: { stream }), + menuConfigurationFactory: JotMenuConfigurationFactory() + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 1) + } +} + +@MainActor +private func firstValue( + of sequence: S +) async throws -> S.Element where S.Element: Sendable { + var iterator = sequence.makeAsyncIterator() + guard let value = try await iterator.next() else { + throw NSError(domain: "JotsViewModelTests", code: 0) + } + return value +} diff --git a/Tests/JotsPage/RenameJotCoordinatorTests.swift b/Tests/JotsPage/RenameJotCoordinatorTests.swift new file mode 100644 index 0000000..65986dc --- /dev/null +++ b/Tests/JotsPage/RenameJotCoordinatorTests.swift @@ -0,0 +1,76 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class RenameJotCoordinatorTests: XCTestCase { + + func test_start_givenInvoked_presentsAlertWithCancelAndRenameActions() { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + let alert = viewController as? UIAlertController + XCTAssertNotNil(alert) + XCTAssertEqual(alert?.actions.count, 2) + XCTAssertEqual(alert?.actions.first?.style, .cancel) + presentExpectation.fulfill() + } + } + ) + let coordinator = RenameJotCoordinator( + jotFileInfo: info, + navigation: navigation, + repository: RenameJotRepositoryMock(), + onRename: { _ in } + ) + + // When + coordinator.start() + + // Then + wait(for: [presentExpectation], timeout: 1) + } + + func test_start_givenCancelTapped_invokesOnEnd() { + // Given + let onEndExpectation = XCTestExpectation(description: "RenameJotCoordinator.onEnd is invoked.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + var alertController: UIAlertController? + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + alertController = viewController as? UIAlertController + } + } + ) + let coordinator = RenameJotCoordinator( + jotFileInfo: info, + navigation: navigation, + repository: RenameJotRepositoryMock(), + onRename: { _ in } + ) + coordinator.onEnd = { onEndExpectation.fulfill() } + + // When + coordinator.start() + let cancelAction = alertController?.actions.first { $0.style == .cancel } + cancelAction?.invokeHandler() + + // Then + wait(for: [onEndExpectation], timeout: 1) + } +} diff --git a/Tests/JotsPage/ShareJotCoordinatorTests.swift b/Tests/JotsPage/ShareJotCoordinatorTests.swift new file mode 100644 index 0000000..a7ab344 --- /dev/null +++ b/Tests/JotsPage/ShareJotCoordinatorTests.swift @@ -0,0 +1,78 @@ +import UIKit +import XCTest + +@testable import Jottre + +@MainActor +final class ShareJotCoordinatorTests: XCTestCase { + + func test_start_givenSuccessfulExport_presentsActivityViewController() async { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present(activity) is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + if viewController is UIActivityViewController { + presentExpectation.fulfill() + } + } + } + ) + let coordinator = ShareJotCoordinator( + jotFileInfo: info, + format: .pdf, + navigation: navigation, + repository: ShareJotRepositoryMock( + exportJotProvider: { _, _ in URL(fileURLWithPath: "/tmp/share.pdf") } + ), + configurePopoverAnchor: { _ in } + ) + + // When + coordinator.start() + + // Then + await fulfillment(of: [presentExpectation], timeout: 5) + } + + func test_start_givenExportThrows_presentsAlertController() async { + // Given + let presentExpectation = XCTestExpectation(description: "Navigation.present(alert) is called.") + let info = JotFile.Info( + url: URL(staticString: "file:///tmp/note.jot"), + name: "note", + modificationDate: nil, + ubiquitousInfo: nil + ) + let navigation = Navigation.test( + presentViewControllerProvider: { viewController, _ in + MainActor.assumeIsolated { + if viewController is UIAlertController { + presentExpectation.fulfill() + } + } + } + ) + let coordinator = ShareJotCoordinator( + jotFileInfo: info, + format: .pdf, + navigation: navigation, + repository: ShareJotRepositoryMock( + exportJotProvider: { _, _ in throw NSError(domain: "test", code: 0) } + ), + configurePopoverAnchor: { _ in } + ) + + // When + coordinator.start() + + // Then + await fulfillment(of: [presentExpectation], timeout: 5) + } +} diff --git a/Tests/JotsPage/ShareJotRepositoryTests.swift b/Tests/JotsPage/ShareJotRepositoryTests.swift index e20c3fa..1470c7b 100644 --- a/Tests/JotsPage/ShareJotRepositoryTests.swift +++ b/Tests/JotsPage/ShareJotRepositoryTests.swift @@ -26,7 +26,7 @@ final class ShareJotRepositoryTests: XCTestCase { func test_exportJot_givenPDFFormat_writesPDFFileToTemporaryDirectoryAndReturnsItsURL() async throws { // Given - let repository = makeRepository() + let repository = try makeRepository() // When let resultURL = try await repository.exportJot(jotFileInfo: makeJotFileInfo(), format: .pdf) @@ -41,7 +41,7 @@ final class ShareJotRepositoryTests: XCTestCase { func test_exportJot_givenJPGFormat_writesJPGFileToTemporaryDirectoryAndReturnsItsURL() async throws { // Given - let repository = makeRepository() + let repository = try makeRepository() // When let resultURL = try await repository.exportJot(jotFileInfo: makeJotFileInfo(), format: .jpg) @@ -55,7 +55,7 @@ final class ShareJotRepositoryTests: XCTestCase { func test_exportJot_givenPNGFormat_writesPNGFileToTemporaryDirectoryAndReturnsItsURL() async throws { // Given - let repository = makeRepository() + let repository = try makeRepository() // When let resultURL = try await repository.exportJot(jotFileInfo: makeJotFileInfo(), format: .png) @@ -90,11 +90,12 @@ final class ShareJotRepositoryTests: XCTestCase { } } - private func makeRepository() -> ShareJotRepository { - ShareJotRepository( + private func makeRepository() throws -> ShareJotRepository { + let fixtureJot = try loadFixtureJot() + return ShareJotRepository( jotFileService: JotFileServiceMock( readJotFileProvider: { jotFileInfo in - JotFile(info: jotFileInfo, jot: Jot.makeEmpty()) + JotFile(info: jotFileInfo, jot: fixtureJot) } ), fileService: FileServiceMock( @@ -103,6 +104,16 @@ final class ShareJotRepositoryTests: XCTestCase { ) } + private func loadFixtureJot() throws -> Jot { + let bundle = Bundle(for: ShareJotRepositoryTests.self) + let fixtureURL = try XCTUnwrap( + bundle.url(forResource: "Calculator Pro", withExtension: "jot"), + "Missing 'Calculator Pro.jot' fixture in test bundle resources." + ) + let data = try Data(contentsOf: fixtureURL) + return try PropertyListDecoder().decode(Jot.self, from: data) + } + private func makeJotFileInfo() -> JotFile.Info { JotFile.Info( url: URL(staticString: "file:///tmp/note.jot"), diff --git a/Tests/Mocks/CloudMigrationCoordinatorMock.swift b/Tests/Mocks/CloudMigrationCoordinatorMock.swift new file mode 100644 index 0000000..12bfdda --- /dev/null +++ b/Tests/Mocks/CloudMigrationCoordinatorMock.swift @@ -0,0 +1,40 @@ +@testable import Jottre + +@MainActor +final class CloudMigrationCoordinatorMock: CloudMigrationCoordinatorProtocol { + + var onEnd: (() -> Void)? + + private let shouldStartProvider: () -> Bool + private let startProvider: () -> Void + private let showInfoAlertProvider: (_ title: String, _ message: String) -> Void + private let dismissProvider: () -> Void + + init( + shouldStartProvider: @escaping () -> Bool = { false }, + startProvider: @escaping () -> Void = {}, + showInfoAlertProvider: @escaping (_ title: String, _ message: String) -> Void = { _, _ in }, + dismissProvider: @escaping () -> Void = {} + ) { + self.shouldStartProvider = shouldStartProvider + self.startProvider = startProvider + self.showInfoAlertProvider = showInfoAlertProvider + self.dismissProvider = dismissProvider + } + + func shouldStart() -> Bool { + shouldStartProvider() + } + + func start() { + startProvider() + } + + func showInfoAlert(title: String, message: String) { + showInfoAlertProvider(title, message) + } + + func dismiss() { + dismissProvider() + } +} diff --git a/Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift b/Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift new file mode 100644 index 0000000..e5274b6 --- /dev/null +++ b/Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift @@ -0,0 +1,21 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class CloudMigrationViewControllerFactoryMock: CloudMigrationViewControllerFactoryProtocol { + + private let makeProvider: @MainActor (_ viewModel: CloudMigrationViewModel) -> UIViewController + + init( + makeProvider: @MainActor @escaping (_ viewModel: CloudMigrationViewModel) -> UIViewController = { _ in + UIViewController() + } + ) { + self.makeProvider = makeProvider + } + + func make(viewModel: CloudMigrationViewModel) -> UIViewController { + makeProvider(viewModel) + } +} diff --git a/Tests/Mocks/CoordinatorFactoryMocks.swift b/Tests/Mocks/CoordinatorFactoryMocks.swift new file mode 100644 index 0000000..abe0be9 --- /dev/null +++ b/Tests/Mocks/CoordinatorFactoryMocks.swift @@ -0,0 +1,153 @@ +import Foundation + +@testable import Jottre + +@MainActor +final class CreateJotCoordinatorFactoryMock: CreateJotCoordinatorFactoryProtocol { + + private let makeProvider: @MainActor (_ navigation: Navigation) -> Coordinator + + init( + makeProvider: @MainActor @escaping (_ navigation: Navigation) -> Coordinator = { _ in CoordinatorMock() } + ) { + self.makeProvider = makeProvider + } + + func make(navigation: Navigation) -> Coordinator { + makeProvider(navigation) + } +} + +@MainActor +final class DeleteJotCoordinatorFactoryMock: DeleteJotCoordinatorFactoryProtocol { + + private let makeProvider: @MainActor (_ jotFileInfo: JotFile.Info, _ navigation: Navigation) -> Coordinator + + init( + makeProvider: + @MainActor @escaping (_ jotFileInfo: JotFile.Info, _ navigation: Navigation) -> Coordinator = { _, _ in + CoordinatorMock() + } + ) { + self.makeProvider = makeProvider + } + + func make(jotFileInfo: JotFile.Info, navigation: Navigation) -> Coordinator { + makeProvider(jotFileInfo, navigation) + } +} + +@MainActor +final class RenameJotCoordinatorFactoryMock: RenameJotCoordinatorFactoryProtocol { + + private let makeProvider: + @MainActor ( + _ jotFileInfo: JotFile.Info, + _ navigation: Navigation, + _ onRename: @Sendable (_ renameJotFileInfo: JotFile.Info) -> Void + ) -> Coordinator + + init( + makeProvider: + @MainActor @escaping ( + _ jotFileInfo: JotFile.Info, + _ navigation: Navigation, + _ onRename: @Sendable (_ renameJotFileInfo: JotFile.Info) -> Void + ) -> Coordinator = { _, _, _ in CoordinatorMock() } + ) { + self.makeProvider = makeProvider + } + + func make( + jotFileInfo: JotFile.Info, + navigation: Navigation, + onRename: @Sendable @escaping (_ renameJotFileInfo: JotFile.Info) -> Void + ) -> Coordinator { + makeProvider(jotFileInfo, navigation, onRename) + } +} + +@MainActor +final class ShareJotCoordinatorFactoryMock: ShareJotCoordinatorFactoryProtocol { + + private let makeProvider: + @MainActor ( + _ jotFileInfo: JotFile.Info, + _ format: ShareFormat, + _ navigation: Navigation, + _ configurePopoverAnchor: PopoverAnchor? + ) -> Coordinator + + init( + makeProvider: + @MainActor @escaping ( + _ jotFileInfo: JotFile.Info, + _ format: ShareFormat, + _ navigation: Navigation, + _ configurePopoverAnchor: PopoverAnchor? + ) -> Coordinator = { _, _, _, _ in CoordinatorMock() } + ) { + self.makeProvider = makeProvider + } + + func make( + jotFileInfo: JotFile.Info, + format: ShareFormat, + navigation: Navigation, + configurePopoverAnchor: PopoverAnchor? + ) -> Coordinator { + makeProvider(jotFileInfo, format, navigation, configurePopoverAnchor) + } +} + +@MainActor +final class RevealFileCoordinatorFactoryMock: RevealFileCoordinatorFactoryProtocol { + + private let makeProvider: @MainActor (_ jotFileInfo: JotFile.Info, _ navigation: Navigation) -> Coordinator + + init( + makeProvider: + @MainActor @escaping (_ jotFileInfo: JotFile.Info, _ navigation: Navigation) -> Coordinator = { _, _ in + CoordinatorMock() + } + ) { + self.makeProvider = makeProvider + } + + func make(jotFileInfo: JotFile.Info, navigation: Navigation) -> Coordinator { + makeProvider(jotFileInfo, navigation) + } +} + +@MainActor +final class JotConflictCoordinatorFactoryMock: JotConflictCoordinatorFactoryProtocol { + + private let makeProvider: + @MainActor ( + _ jotFileInfo: JotFile.Info, + _ jotFileVersions: [JotFileVersion], + _ navigation: Navigation, + _ onResult: @Sendable (_ result: JotConflictResult) -> Void + ) -> Coordinator + + init( + makeProvider: + @MainActor @escaping ( + _ jotFileInfo: JotFile.Info, + _ jotFileVersions: [JotFileVersion], + _ navigation: Navigation, + _ onResult: @Sendable (_ result: JotConflictResult) -> Void + ) -> Coordinator = { _, _, _, _ in CoordinatorMock() } + ) { + self.makeProvider = makeProvider + } + + func make( + jotFileInfo: JotFile.Info, + jotFileVersions: [JotFileVersion], + navigation: Navigation, + onResult: @Sendable @escaping (_ result: JotConflictResult) -> Void + ) -> Coordinator { + makeProvider(jotFileInfo, jotFileVersions, navigation, onResult) + } +} diff --git a/Tests/Mocks/CoordinatorMock.swift b/Tests/Mocks/CoordinatorMock.swift new file mode 100644 index 0000000..d6fa39b --- /dev/null +++ b/Tests/Mocks/CoordinatorMock.swift @@ -0,0 +1,19 @@ +@testable import Jottre + +@MainActor +final class CoordinatorMock: Coordinator { + + var onEnd: (() -> Void)? + + private let startProvider: () -> Void + + init( + startProvider: @escaping () -> Void = {} + ) { + self.startProvider = startProvider + } + + func start() { + startProvider() + } +} diff --git a/Tests/Mocks/EditJotCoordinatorMock.swift b/Tests/Mocks/EditJotCoordinatorMock.swift new file mode 100644 index 0000000..1981e95 --- /dev/null +++ b/Tests/Mocks/EditJotCoordinatorMock.swift @@ -0,0 +1,110 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class EditJotCoordinatorMock: EditJotCoordinatorProtocol { + + private let shouldHandleProvider: (_ url: URL) -> Bool + private let handleProvider: (_ url: URL) -> [UIViewController] + private let showShareJotProvider: + (_ jotFileInfo: JotFile.Info, _ format: ShareFormat, _ configurePopoverAnchor: PopoverAnchor?) -> Void + private let showRenameAlertProvider: (_ jotFileInfo: JotFile.Info) -> Void + private let openDeleteJotProvider: (_ jotFileInfo: JotFile.Info) -> Void + private let openJotProvider: (_ jotFileInfo: JotFile.Info) -> Void + private let showInFilesProvider: (_ jotFileInfo: JotFile.Info) -> Void + private let showJotConflictPageProvider: + ( + _ jotFileInfo: JotFile.Info, + _ jotFileVersions: [JotFileVersion], + _ onResult: @Sendable (_ result: JotConflictResult) -> Void + ) -> Void + private let canGoBackProvider: () -> Bool + private let goBackProvider: () -> Void + private let showInfoAlertProvider: (_ title: String, _ message: String) -> Void + + init( + shouldHandleProvider: @escaping (_ url: URL) -> Bool = { _ in false }, + handleProvider: @escaping (_ url: URL) -> [UIViewController] = { _ in [] }, + showShareJotProvider: + @escaping (_ jotFileInfo: JotFile.Info, _ format: ShareFormat, _ configurePopoverAnchor: PopoverAnchor?) -> + Void = { _, _, _ in }, + showRenameAlertProvider: @escaping (_ jotFileInfo: JotFile.Info) -> Void = { _ in }, + openDeleteJotProvider: @escaping (_ jotFileInfo: JotFile.Info) -> Void = { _ in }, + openJotProvider: @escaping (_ jotFileInfo: JotFile.Info) -> Void = { _ in }, + showInFilesProvider: @escaping (_ jotFileInfo: JotFile.Info) -> Void = { _ in }, + showJotConflictPageProvider: + @escaping ( + _ jotFileInfo: JotFile.Info, + _ jotFileVersions: [JotFileVersion], + _ onResult: @Sendable (_ result: JotConflictResult) -> Void + ) -> Void = { _, _, _ in }, + canGoBackProvider: @escaping () -> Bool = { false }, + goBackProvider: @escaping () -> Void = {}, + showInfoAlertProvider: @escaping (_ title: String, _ message: String) -> Void = { _, _ in } + ) { + self.shouldHandleProvider = shouldHandleProvider + self.handleProvider = handleProvider + self.showShareJotProvider = showShareJotProvider + self.showRenameAlertProvider = showRenameAlertProvider + self.openDeleteJotProvider = openDeleteJotProvider + self.openJotProvider = openJotProvider + self.showInFilesProvider = showInFilesProvider + self.showJotConflictPageProvider = showJotConflictPageProvider + self.canGoBackProvider = canGoBackProvider + self.goBackProvider = goBackProvider + self.showInfoAlertProvider = showInfoAlertProvider + } + + func shouldHandle(url: URL) -> Bool { + shouldHandleProvider(url) + } + + func handle(url: URL) -> [UIViewController] { + handleProvider(url) + } + + func showShareJot( + jotFileInfo: JotFile.Info, + format: ShareFormat, + configurePopoverAnchor: PopoverAnchor? + ) { + showShareJotProvider(jotFileInfo, format, configurePopoverAnchor) + } + + func showRenameAlert(jotFileInfo: JotFile.Info) { + showRenameAlertProvider(jotFileInfo) + } + + func openDeleteJot(jotFileInfo: JotFile.Info) { + openDeleteJotProvider(jotFileInfo) + } + + func openJot(jotFileInfo: JotFile.Info) { + openJotProvider(jotFileInfo) + } + + func showInFiles(jotFileInfo: JotFile.Info) { + showInFilesProvider(jotFileInfo) + } + + func showJotConflictPage( + jotFileInfo: JotFile.Info, + jotFileVersions: [JotFileVersion], + onResult: @Sendable @escaping (_ result: JotConflictResult) -> Void + ) { + showJotConflictPageProvider(jotFileInfo, jotFileVersions, onResult) + } + + func canGoBack() -> Bool { + canGoBackProvider() + } + + func goBack() { + goBackProvider() + } + + func showInfoAlert(title: String, message: String) { + showInfoAlertProvider(title, message) + } +} diff --git a/Tests/Mocks/EditJotRepositoryMock.swift b/Tests/Mocks/EditJotRepositoryMock.swift new file mode 100644 index 0000000..8faea36 --- /dev/null +++ b/Tests/Mocks/EditJotRepositoryMock.swift @@ -0,0 +1,57 @@ +import CoreGraphics +import Foundation +@preconcurrency import PencilKit + +@testable import Jottre + +final class EditJotRepositoryMock: EditJotRepositoryProtocol { + + private let ubiquitousInfoProvider: @Sendable (_ url: URL) -> UbiquitousInfo? + private let readDrawingProvider: + @Sendable (_ jotFileInfo: JotFile.Info) async throws -> (drawing: PKDrawing, width: CGFloat) + private let writeDrawingProvider: @Sendable (_ jotFileInfo: JotFile.Info, _ drawing: PKDrawing) async throws -> Void + private let getConflictingVersionsProvider: @Sendable (_ jotFileInfo: JotFile.Info) -> [JotFileVersion]? + private let duplicateProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> JotFile.Info + + init( + ubiquitousInfoProvider: @Sendable @escaping (_ url: URL) -> UbiquitousInfo? = { _ in nil }, + readDrawingProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info) async throws -> (drawing: PKDrawing, width: CGFloat) = { + _ in (PKDrawing(), 800) + }, + writeDrawingProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ drawing: PKDrawing) async throws -> Void = { _, _ in }, + getConflictingVersionsProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) -> [JotFileVersion]? = { _ in + nil + }, + duplicateProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> JotFile.Info = { jotFileInfo in + jotFileInfo + } + ) { + self.ubiquitousInfoProvider = ubiquitousInfoProvider + self.readDrawingProvider = readDrawingProvider + self.writeDrawingProvider = writeDrawingProvider + self.getConflictingVersionsProvider = getConflictingVersionsProvider + self.duplicateProvider = duplicateProvider + } + + func ubiquitousInfo(url: URL) -> UbiquitousInfo? { + ubiquitousInfoProvider(url) + } + + func readDrawing(jotFileInfo: JotFile.Info) async throws -> (drawing: PKDrawing, width: CGFloat) { + try await readDrawingProvider(jotFileInfo) + } + + func writeDrawing(jotFileInfo: JotFile.Info, drawing: PKDrawing) async throws { + try await writeDrawingProvider(jotFileInfo, drawing) + } + + func getConflictingVersions(jotFileInfo: JotFile.Info) -> [JotFileVersion]? { + getConflictingVersionsProvider(jotFileInfo) + } + + func duplicate(jotFileInfo: JotFile.Info) throws -> JotFile.Info { + try duplicateProvider(jotFileInfo) + } +} diff --git a/Tests/Mocks/EditJotViewControllerFactoryMock.swift b/Tests/Mocks/EditJotViewControllerFactoryMock.swift new file mode 100644 index 0000000..adb77fc --- /dev/null +++ b/Tests/Mocks/EditJotViewControllerFactoryMock.swift @@ -0,0 +1,22 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class EditJotViewControllerFactoryMock: EditJotViewControllerFactoryProtocol { + + private let makeProvider: + @MainActor (_ jotFileInfo: JotFile.Info, _ coordinator: EditJotCoordinatorProtocol) -> UIViewController + + init( + makeProvider: + @MainActor @escaping (_ jotFileInfo: JotFile.Info, _ coordinator: EditJotCoordinatorProtocol) -> + UIViewController = { _, _ in UIViewController() } + ) { + self.makeProvider = makeProvider + } + + func make(jotFileInfo: JotFile.Info, coordinator: EditJotCoordinatorProtocol) -> UIViewController { + makeProvider(jotFileInfo, coordinator) + } +} diff --git a/Tests/Mocks/EnableCloudCoordinatorMock.swift b/Tests/Mocks/EnableCloudCoordinatorMock.swift new file mode 100644 index 0000000..0f36b89 --- /dev/null +++ b/Tests/Mocks/EnableCloudCoordinatorMock.swift @@ -0,0 +1,33 @@ +@testable import Jottre + +@MainActor +final class EnableCloudCoordinatorMock: EnableCloudCoordinatorProtocol { + + var onEnd: (() -> Void)? + + private let startProvider: () -> Void + private let openLearnHowToEnableProvider: () -> Void + private let dismissProvider: () -> Void + + init( + startProvider: @escaping () -> Void = {}, + openLearnHowToEnableProvider: @escaping () -> Void = {}, + dismissProvider: @escaping () -> Void = {} + ) { + self.startProvider = startProvider + self.openLearnHowToEnableProvider = openLearnHowToEnableProvider + self.dismissProvider = dismissProvider + } + + func start() { + startProvider() + } + + func openLearnHowToEnable() { + openLearnHowToEnableProvider() + } + + func dismiss() { + dismissProvider() + } +} diff --git a/Tests/Mocks/EnableCloudViewControllerFactoryMock.swift b/Tests/Mocks/EnableCloudViewControllerFactoryMock.swift new file mode 100644 index 0000000..c719438 --- /dev/null +++ b/Tests/Mocks/EnableCloudViewControllerFactoryMock.swift @@ -0,0 +1,21 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class EnableCloudViewControllerFactoryMock: EnableCloudViewControllerFactoryProtocol { + + private let makeProvider: @MainActor (_ coordinator: EnableCloudCoordinatorProtocol) -> UIViewController + + init( + makeProvider: @MainActor @escaping (_ coordinator: EnableCloudCoordinatorProtocol) -> UIViewController = { _ in + UIViewController() + } + ) { + self.makeProvider = makeProvider + } + + func make(coordinator: EnableCloudCoordinatorProtocol) -> UIViewController { + makeProvider(coordinator) + } +} diff --git a/Tests/Mocks/JotConflictCoordinatorMock.swift b/Tests/Mocks/JotConflictCoordinatorMock.swift new file mode 100644 index 0000000..ee43de2 --- /dev/null +++ b/Tests/Mocks/JotConflictCoordinatorMock.swift @@ -0,0 +1,33 @@ +@testable import Jottre + +@MainActor +final class JotConflictCoordinatorMock: JotConflictCoordinatorProtocol { + + var onEnd: (() -> Void)? + + private let startProvider: () -> Void + private let showInfoAlertProvider: (_ title: String, _ message: String) -> Void + private let dismissProvider: (_ completion: @Sendable () -> Void) -> Void + + init( + startProvider: @escaping () -> Void = {}, + showInfoAlertProvider: @escaping (_ title: String, _ message: String) -> Void = { _, _ in }, + dismissProvider: @escaping (_ completion: @Sendable () -> Void) -> Void = { _ in } + ) { + self.startProvider = startProvider + self.showInfoAlertProvider = showInfoAlertProvider + self.dismissProvider = dismissProvider + } + + func start() { + startProvider() + } + + func showInfoAlert(title: String, message: String) { + showInfoAlertProvider(title, message) + } + + func dismiss(completion: @Sendable @escaping () -> Void) { + dismissProvider(completion) + } +} diff --git a/Tests/Mocks/JotConflictViewControllerFactoryMock.swift b/Tests/Mocks/JotConflictViewControllerFactoryMock.swift new file mode 100644 index 0000000..a655e94 --- /dev/null +++ b/Tests/Mocks/JotConflictViewControllerFactoryMock.swift @@ -0,0 +1,21 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class JotConflictViewControllerFactoryMock: JotConflictViewControllerFactoryProtocol { + + private let makeProvider: @MainActor (_ viewModel: JotConflictViewModel) -> UIViewController + + init( + makeProvider: @MainActor @escaping (_ viewModel: JotConflictViewModel) -> UIViewController = { _ in + UIViewController() + } + ) { + self.makeProvider = makeProvider + } + + func make(viewModel: JotConflictViewModel) -> UIViewController { + makeProvider(viewModel) + } +} diff --git a/Tests/Mocks/JotsCoordinatorMock.swift b/Tests/Mocks/JotsCoordinatorMock.swift new file mode 100644 index 0000000..db75b05 --- /dev/null +++ b/Tests/Mocks/JotsCoordinatorMock.swift @@ -0,0 +1,82 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class JotsCoordinatorMock: JotsCoordinatorProtocol { + + private let shouldHandleProvider: (_ url: URL) -> Bool + private let handleProvider: (_ url: URL) -> [UIViewController] + private let openSettingsProvider: () -> Void + private let openCreateJotProvider: () -> Void + private let openJotProvider: (_ jotFileInfo: JotFile.Info, _ prefersNewWindow: Bool) -> Void + private let openEnableCloudPageProvider: () -> Void + private let showShareJotProvider: + (_ jotFileInfo: JotFile.Info, _ format: ShareFormat, _ configurePopoverAnchor: PopoverAnchor?) -> Void + private let showRenameAlertProvider: (_ jotFileInfo: JotFile.Info) -> Void + private let openDeleteJotProvider: (_ jotFileInfo: JotFile.Info) -> Void + private let showInfoAlertProvider: (_ title: String, _ message: String) -> Void + private let showInFilesProvider: (_ jotFileInfo: JotFile.Info) -> Void + + init( + shouldHandleProvider: @escaping (_ url: URL) -> Bool = { _ in false }, + handleProvider: @escaping (_ url: URL) -> [UIViewController] = { _ in [] }, + openSettingsProvider: @escaping () -> Void = {}, + openCreateJotProvider: @escaping () -> Void = {}, + openJotProvider: @escaping (_ jotFileInfo: JotFile.Info, _ prefersNewWindow: Bool) -> Void = { _, _ in }, + openEnableCloudPageProvider: @escaping () -> Void = {}, + showShareJotProvider: + @escaping (_ jotFileInfo: JotFile.Info, _ format: ShareFormat, _ configurePopoverAnchor: PopoverAnchor?) -> + Void = { _, _, _ in }, + showRenameAlertProvider: @escaping (_ jotFileInfo: JotFile.Info) -> Void = { _ in }, + openDeleteJotProvider: @escaping (_ jotFileInfo: JotFile.Info) -> Void = { _ in }, + showInfoAlertProvider: @escaping (_ title: String, _ message: String) -> Void = { _, _ in }, + showInFilesProvider: @escaping (_ jotFileInfo: JotFile.Info) -> Void = { _ in } + ) { + self.shouldHandleProvider = shouldHandleProvider + self.handleProvider = handleProvider + self.openSettingsProvider = openSettingsProvider + self.openCreateJotProvider = openCreateJotProvider + self.openJotProvider = openJotProvider + self.openEnableCloudPageProvider = openEnableCloudPageProvider + self.showShareJotProvider = showShareJotProvider + self.showRenameAlertProvider = showRenameAlertProvider + self.openDeleteJotProvider = openDeleteJotProvider + self.showInfoAlertProvider = showInfoAlertProvider + self.showInFilesProvider = showInFilesProvider + } + + func shouldHandle(url: URL) -> Bool { + shouldHandleProvider(url) + } + + func handle(url: URL) -> [UIViewController] { + handleProvider(url) + } + + func openSettings() { openSettingsProvider() } + func openCreateJot() { openCreateJotProvider() } + func openJot(jotFileInfo: JotFile.Info, prefersNewWindow: Bool) { + openJotProvider(jotFileInfo, prefersNewWindow) + } + func openEnableCloudPage() { openEnableCloudPageProvider() } + func showShareJot( + jotFileInfo: JotFile.Info, + format: ShareFormat, + configurePopoverAnchor: PopoverAnchor? + ) { + showShareJotProvider(jotFileInfo, format, configurePopoverAnchor) + } + func showRenameAlert(jotFileInfo: JotFile.Info) { + showRenameAlertProvider(jotFileInfo) + } + func openDeleteJot(jotFileInfo: JotFile.Info) { + openDeleteJotProvider(jotFileInfo) + } + func showInfoAlert(title: String, message: String) { + showInfoAlertProvider(title, message) + } + func showInFiles(jotFileInfo: JotFile.Info) { + showInFilesProvider(jotFileInfo) + } +} diff --git a/Tests/Mocks/JotsViewControllerFactoryMock.swift b/Tests/Mocks/JotsViewControllerFactoryMock.swift new file mode 100644 index 0000000..004f267 --- /dev/null +++ b/Tests/Mocks/JotsViewControllerFactoryMock.swift @@ -0,0 +1,21 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class JotsViewControllerFactoryMock: JotsViewControllerFactoryProtocol { + + private let makeProvider: @MainActor (_ coordinator: JotsCoordinatorProtocol) -> UIViewController + + init( + makeProvider: @MainActor @escaping (_ coordinator: JotsCoordinatorProtocol) -> UIViewController = { _ in + UIViewController() + } + ) { + self.makeProvider = makeProvider + } + + func make(coordinator: JotsCoordinatorProtocol) -> UIViewController { + makeProvider(coordinator) + } +} diff --git a/Tests/Mocks/PageCoordinatorFactoryMocks.swift b/Tests/Mocks/PageCoordinatorFactoryMocks.swift new file mode 100644 index 0000000..94928e5 --- /dev/null +++ b/Tests/Mocks/PageCoordinatorFactoryMocks.swift @@ -0,0 +1,95 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class SettingsCoordinatorFactoryMock: SettingsCoordinatorFactoryProtocol { + + private let makeProvider: @MainActor (_ navigation: Navigation) -> Coordinator + + init( + makeProvider: @MainActor @escaping (_ navigation: Navigation) -> Coordinator = { _ in CoordinatorMock() } + ) { + self.makeProvider = makeProvider + } + + func make(navigation: Navigation) -> Coordinator { + makeProvider(navigation) + } +} + +@MainActor +final class EnableCloudCoordinatorFactoryMock: EnableCloudCoordinatorFactoryProtocol { + + private let makeProvider: @MainActor (_ navigation: Navigation) -> Coordinator + + init( + makeProvider: @MainActor @escaping (_ navigation: Navigation) -> Coordinator = { _ in CoordinatorMock() } + ) { + self.makeProvider = makeProvider + } + + func make(navigation: Navigation) -> Coordinator { + makeProvider(navigation) + } +} + +@MainActor +final class EditJotCoordinatorFactoryMock: EditJotCoordinatorFactoryProtocol { + + private let makeProvider: @MainActor (_ navigation: Navigation) -> NavigationCoordinator + + init( + makeProvider: + @MainActor @escaping (_ navigation: Navigation) -> NavigationCoordinator = { _ in + NavigationCoordinatorMock() + } + ) { + self.makeProvider = makeProvider + } + + func make(navigation: Navigation) -> NavigationCoordinator { + makeProvider(navigation) + } +} + +@MainActor +final class CloudMigrationCoordinatorFactoryMock: CloudMigrationCoordinatorFactoryProtocol { + + private let makeProvider: @MainActor (_ navigation: Navigation) -> CloudMigrationCoordinatorProtocol + + init( + makeProvider: @MainActor @escaping (_ navigation: Navigation) -> CloudMigrationCoordinatorProtocol = { _ in + CloudMigrationCoordinatorMock() + } + ) { + self.makeProvider = makeProvider + } + + func make(navigation: Navigation) -> CloudMigrationCoordinatorProtocol { + makeProvider(navigation) + } +} + +@MainActor +final class NavigationCoordinatorMock: NavigationCoordinator { + + private let shouldHandleProvider: (_ url: URL) -> Bool + private let handleProvider: (_ url: URL) -> [UIViewController] + + init( + shouldHandleProvider: @escaping (_ url: URL) -> Bool = { _ in false }, + handleProvider: @escaping (_ url: URL) -> [UIViewController] = { _ in [] } + ) { + self.shouldHandleProvider = shouldHandleProvider + self.handleProvider = handleProvider + } + + func shouldHandle(url: URL) -> Bool { + shouldHandleProvider(url) + } + + func handle(url: URL) -> [UIViewController] { + handleProvider(url) + } +} diff --git a/Tests/Mocks/SettingsCoordinatorMock.swift b/Tests/Mocks/SettingsCoordinatorMock.swift new file mode 100644 index 0000000..762bca2 --- /dev/null +++ b/Tests/Mocks/SettingsCoordinatorMock.swift @@ -0,0 +1,35 @@ +import Foundation + +@testable import Jottre + +@MainActor +final class SettingsCoordinatorMock: SettingsCoordinatorProtocol { + + var onEnd: (() -> Void)? + + private let startProvider: () -> Void + private let openExternalLinkProvider: (_ url: URL) -> Void + private let dismissProvider: () -> Void + + init( + startProvider: @escaping () -> Void = {}, + openExternalLinkProvider: @escaping (_ url: URL) -> Void = { _ in }, + dismissProvider: @escaping () -> Void = {} + ) { + self.startProvider = startProvider + self.openExternalLinkProvider = openExternalLinkProvider + self.dismissProvider = dismissProvider + } + + func start() { + startProvider() + } + + func openExternalLink(url: URL) { + openExternalLinkProvider(url) + } + + func dismiss() { + dismissProvider() + } +} diff --git a/Tests/Mocks/SettingsRepositoryMock.swift b/Tests/Mocks/SettingsRepositoryMock.swift new file mode 100644 index 0000000..821c7e3 --- /dev/null +++ b/Tests/Mocks/SettingsRepositoryMock.swift @@ -0,0 +1,41 @@ +import UIKit + +@testable import Jottre + +final class SettingsRepositoryMock: SettingsRepositoryProtocol { + + private let shouldShowEnableICloudButtonProvider: @Sendable () -> Bool + private let appVersionProvider: @Sendable () -> String + private let userInterfaceStyleProvider: @Sendable () -> AsyncStream + private let updateUserInterfaceStyleProvider: @Sendable (_ style: UIUserInterfaceStyle) -> Void + + init( + shouldShowEnableICloudButtonProvider: @Sendable @escaping () -> Bool = { false }, + appVersionProvider: @Sendable @escaping () -> String = { "" }, + userInterfaceStyleProvider: @Sendable @escaping () -> AsyncStream = { + AsyncStream { $0.finish() } + }, + updateUserInterfaceStyleProvider: @Sendable @escaping (_ style: UIUserInterfaceStyle) -> Void = { _ in } + ) { + self.shouldShowEnableICloudButtonProvider = shouldShowEnableICloudButtonProvider + self.appVersionProvider = appVersionProvider + self.userInterfaceStyleProvider = userInterfaceStyleProvider + self.updateUserInterfaceStyleProvider = updateUserInterfaceStyleProvider + } + + func shouldShowEnableICloudButton() -> Bool { + shouldShowEnableICloudButtonProvider() + } + + func appVersion() -> String { + appVersionProvider() + } + + func userInterfaceStyle() -> AsyncStream { + userInterfaceStyleProvider() + } + + func updateUserInterfaceStyle(_ style: UIUserInterfaceStyle) { + updateUserInterfaceStyleProvider(style) + } +} diff --git a/Tests/Mocks/SettingsViewControllerFactoryMock.swift b/Tests/Mocks/SettingsViewControllerFactoryMock.swift new file mode 100644 index 0000000..44f0269 --- /dev/null +++ b/Tests/Mocks/SettingsViewControllerFactoryMock.swift @@ -0,0 +1,21 @@ +import UIKit + +@testable import Jottre + +@MainActor +final class SettingsViewControllerFactoryMock: SettingsViewControllerFactoryProtocol { + + private let makeProvider: @MainActor (_ coordinator: SettingsCoordinatorProtocol) -> UIViewController + + init( + makeProvider: @MainActor @escaping (_ coordinator: SettingsCoordinatorProtocol) -> UIViewController = { _ in + UIViewController() + } + ) { + self.makeProvider = makeProvider + } + + func make(coordinator: SettingsCoordinatorProtocol) -> UIViewController { + makeProvider(coordinator) + } +} diff --git a/Tests/Mocks/SubCoordinatorRepositoryMocks.swift b/Tests/Mocks/SubCoordinatorRepositoryMocks.swift new file mode 100644 index 0000000..5500f35 --- /dev/null +++ b/Tests/Mocks/SubCoordinatorRepositoryMocks.swift @@ -0,0 +1,82 @@ +import Foundation + +@testable import Jottre + +final class CreateJotRepositoryMock: CreateJotRepositoryProtocol { + + private let createJotProvider: @Sendable (_ name: String) async throws -> JotFile.Info + + init( + createJotProvider: + @Sendable @escaping (_ name: String) async throws -> JotFile.Info = { name in + JotFile.Info( + url: URL(fileURLWithPath: "/tmp/\(name).jot"), + name: name, + modificationDate: nil, + ubiquitousInfo: nil + ) + } + ) { + self.createJotProvider = createJotProvider + } + + func createJot(name: String) async throws -> JotFile.Info { + try await createJotProvider(name) + } +} + +final class DeleteJotRepositoryMock: DeleteJotRepositoryProtocol { + + private let deleteJotProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> Void + + init( + deleteJotProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> Void = { _ in } + ) { + self.deleteJotProvider = deleteJotProvider + } + + func deleteJot(jotFileInfo: JotFile.Info) throws { + try deleteJotProvider(jotFileInfo) + } +} + +final class RenameJotRepositoryMock: RenameJotRepositoryProtocol { + + private let renameProvider: (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info + + init( + renameProvider: + @escaping (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info = { jotFileInfo, name in + JotFile.Info( + url: jotFileInfo.url.deletingLastPathComponent().appendingPathComponent("\(name).jot"), + name: name, + modificationDate: nil, + ubiquitousInfo: nil + ) + } + ) { + self.renameProvider = renameProvider + } + + func rename(jotFileInfo: JotFile.Info, newName: String) throws -> JotFile.Info { + try renameProvider(jotFileInfo, newName) + } +} + +final class ShareJotRepositoryMock: ShareJotRepositoryProtocol { + + private let exportJotProvider: @Sendable (_ jotFileInfo: JotFile.Info, _ format: ShareFormat) async throws -> URL + + init( + exportJotProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ format: ShareFormat) async throws -> URL = { _, _ in + URL(fileURLWithPath: "/tmp/share") + } + ) { + self.exportJotProvider = exportJotProvider + } + + func exportJot(jotFileInfo: JotFile.Info, format: ShareFormat) async throws -> URL { + try await exportJotProvider(jotFileInfo, format) + } +} diff --git a/Tests/Resources/Calculator Pro.jot b/Tests/Resources/Calculator Pro.jot new file mode 100644 index 0000000000000000000000000000000000000000..f3c429701907c68087b2ecf59004dac70d3e3bb9 GIT binary patch literal 779239 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 z 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 -;5y`P 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%0A{92C*Hi4&)o=s7nRKigiq7!ZFU;$JW8 z?+f2G{c*_gnqiwa6t<}z9NO+DApS-~t$+XGrPW>J2m1-vvbT(V5S4iP2O$1I#D@Py zw9+0_{4UPQY*&jBJwD%Dyb%zCwE(fvzY$AbZtW6puV(V5=U@E+#1KSm{BOjL z8%-{%ZL=G^)9&qwU;7#j0>n^6Z1Qi!_xt)gw0&)>nNqW{*kIvBwno*Byr4Y7?`-dR`c^E|xB6^O~- zf~2*$vsnLb0|<76PiU6u?NFU&`T17kp#Ek$%db4peOnIhm9a{&V@-?y8VHU+Yk@n9L zNv@iCf(vzOn?-SA#@>bNNpXWcaW1q|-z6B%TXei}V4 zxX>dGSrp3>CJo6VsT!aEz%RRJQOtsU9kGpQYd-GaN|UB!QB?5xAGVQ!n)@wXsrAe( zit#${VL8NE({#Ek&7Pk{(FBZ5%^@>2AH}%R28;1~9$1{p&mmr#O%J)!mdmmz3RtI` zImB1?19O9=L(a?=5W3nhFDmOpMAelW^4YQ=}vRsWKqnx_0G&8<1{m)+-djP zEQ&FVtQk3kXcla9r!Cd8DHb)Z(9R+HntzJj>D{K;6r+wQ1=~mm&CK`i^jf!Uic!a) zsBNTHL)vgW^)k$+7$PZXk5SS zPM=w2Q&bA3QQ2gG#+5{OddDdnzHqbBTD+As)DXG3)3P~x4 z$);EkP&pu-l&iOH<4(0^XH$$H7XL~kmFfo7ZnWFNY`Sk@jxv6HI{B!6<$@c{56Gsq zfjg9!OVf!=BX5%%y&9EGaZB)duME;r18K2gZ8lA7yI1+hV=J-Is2t!%^RlujHiH~< z$|T+z`_wK%W6EVca)`C&ygsgUUTrqTvW5@QIb@0^ zzNRsCR|DS5q?fQ`+Ca&$4 zoQAbabf`GF?z~a5Z|dud}C~$FMEi8qBvjw@Ako z5TmrT+b~42wq|QdXAO?HZp=GTEg2RYHAko}pLOscAVwo17e*?G`s>C#xgKR598=*; znx}@Y1H_ex$Q82+V&lx3j^qE>cUtk%rKJ0U!CwF|1`$y)|DQj-x28#)!Tce=cBiHG zwfnim9uQ*@5f$_QLCnk;Gx2Gx&D{j|xvop5bua+LI7CFnjEJJY4)e$N!+95dVcZ&* z1}U9qkYqrN*U}c(T~8B0)a0k`@3vn&@|}H6PG9kq%WmDX05Jg(@zf%16-2}D%l6)F zD2TSVvuSwwetHT=Y*hD)ZQ&Qy`7e%ooUd=7Pt1>{9zVChWR@l%CTeM`)gd+mL@kck zY-lUprE%n8>fD1r-mP-BicDc&fwc-8%2`8~E-R4T#Bz$SLy|;yH*B zC%W2Sk^H7Qd3!2tN^-Y#1Ls~#A_|9%kyptogx}qjr1*oFX?0z;c!BDGoqVS^F7A_znfKFYChoW zTIHQMDkv0sR+r!80bI}OcGzKn_p<6W{*d5pp${iGC|GD3SoPYpPq3}%ZKZj858(B& zy4`KJFg~HLRfTB|{2fE9J$gxkNMvL6bylKqd#jDr8}E4GYfn2X&2O;)cd*hN7z_X2 z0lq6nXufBd)%b*!La*_T@O>-bcZOSOj*EozhsrYpJ=X*I~FIoHYv?SI3);h_Q zg^5c$J_793TH2lJBp3d6LsEEcSLEdeh~1fF9^DdXuUHl5zIR*AQgy&yqov)jj-xvO zb|X^pAmMr*!*7br@xaImYb4&!l-h|jFuK&VL&po*6D8t@(C{4GY4|%;}UP54_?$2fd z_GZLJnf*8RugG|7$75iB4hV}fsUoW2Q{aAxSF%_}VqxuWGaQB(a2zDnu%^$of zemCq?zGF(uk&${yfV~B=(XILmyW-4)^P3r;%(kE1(#_C*XnLG>ne~@8Xl|z=Hu_e7 zVW;OmJ9&tGiTU<|@rp|hSF@VWn;Sj+XAEGcBQ`o%e_$Ji-F)p-9m55}hm2+`PM=SoI}Nb6A~w2Oe_>Y~-udtZ zyTRQq&$<|nw5#0wbh-8z#kN$y&O~hVxBkKoiTNIOklo3+yp4an3vCnf2fy!d)O|)7 zU}qsVI$eKbpSp2-J3D3d+GjUSW)ONbc-ikyu6g(+*@%sv*WcLrkDhYu*(17sp5kd8 zc+6y7+2lh*)Bt-MVx#-@7k1&AKhJ{MDHVpt+X?-K^$XtBZ%bz{Q*^Cz5F354zp+p4 z48Op>d+=Dv@mG4oMuqFQ>DD%4rUPJaM{IP&{=!Z_QbIizF8vYJLl^KBXd_AbP3u7Vws^RzsLVQ014uxjoVp?i*Y=Bd_CXLkea-H6>n z6}#+kSOLTCdo@<6JUpyNK?Bph)_*O( zrzfOry2$Tj{;?hH92`3xYFBQu-!%{ox`T+_P6fN-?$cex>`UU@k`jNtw;LUQ?!o*q z)kh}-b}nMKSH<2Eci<<(mOR=0E6~}od%{KIsd~G69|G({h}}U2J7n9{b=%nux<55K zbLWh0zi657>A`yM%mMo_Vs})*PCtL__FIPi**tCh<^fLkGDhs4?YTHi7qE{Yb|)3= zkkHJ}ciEk2FUbD-;Kq=gqeb5uJzpFs1?)V;?yQ1cSdg-Y^S7an)}vJ(L-%ZLu=m8` z6Qx@K`zT^}QN>>UwXBMLNlxD>rgM%vOv>+{b^Um3R3KpIBX(C6?1~+iA4W0ky-pFo z?>(_Qv&HXBwuQFF3BW#v*xgjH(}TBvJIrqIh0BujGnd-ziro>qY{s}I;ecI$*xgmI z3!jFpc*cHv(vCSFZ;Y^g5-Sf@D4w@S2khgB-9rVt;!Vi)1a>DnWeLMunA*989p5^~ zUeSIfV4py2T~+MEQLpwhJ_)??bhQ2&>#c`!T9+lAcrpO6Pa?LS3UHO!r!@cZoQ#MU_Xp7Rm2(k55vG+W_bcx-`yR49HDaGVwp3#`cTMjfs zi{mt68>nCxemk;l75nYszYCf+u(h2QmE&mZFU{Kz*k=&Cw<>o2+ixEkb;ie>j`TMX z+D3Q0K5M?MJ$}hq#O|YtUGV40QFh8vjUEJ;t#KT*|6vo^sFIav&74E*zAD%ukJlav zX5X!D)}lvo>*2FEg+0xUAVvC*Bv { continuation in + continuation.yield(.unspecified) + continuation.finish() + } + let viewModel = SettingsViewModel( + repository: SettingsRepositoryMock( + shouldShowEnableICloudButtonProvider: { false }, + appVersionProvider: { "1.2.3" }, + userInterfaceStyleProvider: { userInterfaceStyleStream } + ), + coordinator: SettingsCoordinatorMock() + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 3) + XCTAssertNotNil(items[0].id as? SettingsDropdownBusinessModel) + XCTAssertNotNil(items[1].id as? SettingsExternalLinkBusinessModel) + XCTAssertNotNil(items[2].id as? SettingsInfoBusinessModel) + let info = try XCTUnwrap(items[2].id as? SettingsInfoBusinessModel) + XCTAssertEqual(info.value, "1.2.3") + } + + func test_didLoad_givenShouldShowICloud_yieldsFourItemsWithICloudLink() async throws { + // Given + let userInterfaceStyleStream = AsyncStream { continuation in + continuation.yield(.dark) + continuation.finish() + } + let viewModel = SettingsViewModel( + repository: SettingsRepositoryMock( + shouldShowEnableICloudButtonProvider: { true }, + userInterfaceStyleProvider: { userInterfaceStyleStream } + ), + coordinator: SettingsCoordinatorMock() + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + + // Then + XCTAssertEqual(items.count, 4) + XCTAssertNotNil(items[1].id as? SettingsExternalLinkBusinessModel) + XCTAssertNotNil(items[2].id as? SettingsExternalLinkBusinessModel) + } + + func test_didLoad_givenDarkStyle_yieldsDropdownWithDarkAsCurrent() async throws { + // Given + let userInterfaceStyleStream = AsyncStream { continuation in + continuation.yield(.dark) + continuation.finish() + } + let viewModel = SettingsViewModel( + repository: SettingsRepositoryMock( + userInterfaceStyleProvider: { userInterfaceStyleStream } + ), + coordinator: SettingsCoordinatorMock() + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + + // Then + let dropdown = try XCTUnwrap(items[0].id as? SettingsDropdownBusinessModel) + XCTAssertEqual(dropdown.current.value as? UIUserInterfaceStyle, .dark) + XCTAssertEqual(dropdown.options.count, 3) + } + + func test_didLoadExternalLinkTap_givenICloudVisible_invokesOpenExternalLinkWithICloudURL() async throws { + // Given + let openExternalLinkExpectation = + XCTestExpectation(description: "SettingsCoordinatorMock.openExternalLink is called.") + let userInterfaceStyleStream = AsyncStream { continuation in + continuation.yield(.unspecified) + continuation.finish() + } + let coordinatorMock = SettingsCoordinatorMock( + openExternalLinkProvider: { receivedURL in + // Then + XCTAssertEqual(receivedURL, EnableICloudSupportURL().toURL()) + openExternalLinkExpectation.fulfill() + } + ) + let viewModel = SettingsViewModel( + repository: SettingsRepositoryMock( + shouldShowEnableICloudButtonProvider: { true }, + userInterfaceStyleProvider: { userInterfaceStyleStream } + ), + coordinator: coordinatorMock + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + items[1].handleAction(.tap) + + // Then + await fulfillment(of: [openExternalLinkExpectation], timeout: 1) + } + + func test_didLoadExternalLinkTap_givenGithubLink_invokesOpenExternalLinkWithGithubURL() async throws { + // Given + let openExternalLinkExpectation = + XCTestExpectation(description: "SettingsCoordinatorMock.openExternalLink is called.") + let userInterfaceStyleStream = AsyncStream { continuation in + continuation.yield(.unspecified) + continuation.finish() + } + let coordinatorMock = SettingsCoordinatorMock( + openExternalLinkProvider: { receivedURL in + // Then + XCTAssertEqual(receivedURL, JottreGithubURL().toURL()) + openExternalLinkExpectation.fulfill() + } + ) + let viewModel = SettingsViewModel( + repository: SettingsRepositoryMock( + shouldShowEnableICloudButtonProvider: { false }, + userInterfaceStyleProvider: { userInterfaceStyleStream } + ), + coordinator: coordinatorMock + ) + + // When + viewModel.didLoad() + let items = try await firstValue(of: viewModel.items) + items[1].handleAction(.tap) + + // Then + await fulfillment(of: [openExternalLinkExpectation], timeout: 1) + } +} + +@MainActor +private func firstValue( + of sequence: S +) async throws -> S.Element where S.Element: Sendable { + var iterator = sequence.makeAsyncIterator() + guard let value = try await iterator.next() else { + throw NSError(domain: "SettingsViewModelTests", code: 0) + } + return value +} diff --git a/project.yml b/project.yml index 81a20b6..48da6c1 100644 --- a/project.yml +++ b/project.yml @@ -127,7 +127,11 @@ targets: platform: iOS deploymentTarget: "15.0" sources: - - Tests + - path: Tests + excludes: + - Resources/** + - path: Tests/Resources + buildPhase: resources dependencies: - target: Jottre settings: From 6de4e9d3004db9b0b673fff2644c4d1af6e6cdab Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Sat, 9 May 2026 11:00:11 +0200 Subject: [PATCH 5/9] Integrates test lane into pull-request actions (#124) --- .github/workflows/pull_request.yml | 13 +++++++++++++ fastlane/Fastfile | 12 ++++++++++++ fastlane/README.md | 8 ++++++++ 3 files changed, 33 insertions(+) diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml index d652d72..793f905 100644 --- a/.github/workflows/pull_request.yml +++ b/.github/workflows/pull_request.yml @@ -34,6 +34,19 @@ jobs: bundler-cache: true - run: bundle exec rubocop + test: + name: Test + runs-on: macos-26 + timeout-minutes: 10 + steps: + - uses: actions/checkout@v4 + - uses: ruby/setup-ruby@v1 + with: + bundler-cache: true + - name: Install XcodeGen + run: brew install xcodegen + - run: bundle exec fastlane ios test + build-ios-debug: name: Build iOS/iPadOS Debug runs-on: macos-26 diff --git a/fastlane/Fastfile b/fastlane/Fastfile index c0115e5..4fa443f 100644 --- a/fastlane/Fastfile +++ b/fastlane/Fastfile @@ -141,6 +141,18 @@ platform :ios do sh('xcodegen generate --spec ../project.yml') end + desc 'Run unit tests' + lane :test do + generate_project + + run_tests( + scheme: SCHEME, + destination: 'platform=iOS Simulator,name=iPhone 17', + xcargs: NO_SIGN_XCARGS, + output_directory: 'build' + ) + end + desc 'Verify iOS/iPadOS debug build' lane :build_debug do generate_project diff --git a/fastlane/README.md b/fastlane/README.md index 4e4eba8..23fc852 100644 --- a/fastlane/README.md +++ b/fastlane/README.md @@ -42,6 +42,14 @@ Bump version from merge commit and push tag Generate the Xcode project using XcodeGen +### ios test + +```sh +[bundle exec] fastlane ios test +``` + +Run unit tests + ### ios build_debug ```sh From 68c8b54ebf953a30106574082281b9990850ab46 Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Sat, 9 May 2026 11:00:23 +0200 Subject: [PATCH 6/9] Adds license header (#124) --- .../CloudImageCellViewModelTests.swift | 19 ++++- .../CloudMigrationCoordinatorTests.swift | 18 ++++ .../CloudMigrationJotBusinessModelTests.swift | 18 ++++ .../CloudMigrationJotCellViewModelTests.swift | 18 ++++ .../CloudMigrationRepositoryTests.swift | 18 ++++ .../CloudMigrationViewModelTests.swift | 18 ++++ .../DefaultsContinuationStorageTests.swift | 19 ++++- Tests/Defaults/DefaultsKeyTests.swift | 18 ++++ Tests/Defaults/DefaultsServiceTests.swift | 19 ++++- .../EditJotPage/EditJotCoordinatorTests.swift | 18 ++++ .../EditJotPage/EditJotRepositoryTests.swift | 18 ++++ Tests/EditJotPage/EditJotViewModelTests.swift | 18 ++++ .../EnableCloudCoordinatorTests.swift | 18 ++++ .../EnableCloudViewModelTests.swift | 18 ++++ .../FeatureRowCellViewModelTests.swift | 18 ++++ Tests/FileService/LocalFileServiceTests.swift | 18 ++++ Tests/FileService/UbiquitousInfoTests.swift | 18 ++++ Tests/Helpers/Navigation+test.swift | 18 ++++ Tests/Helpers/UIAlertAction+invoke.swift | 18 ++++ Tests/Helpers/URL+staticString.swift | 18 ++++ ...rviceDocumentsDirectoryContentsTests.swift | 18 ++++ Tests/Jot/JotFileServiceTests.swift | 18 ++++ Tests/Jot/JotFileTests.swift | 18 ++++ .../JotConflictBusinessModelTests.swift | 18 ++++ .../JotConflictCellViewModelTests.swift | 18 ++++ .../JotConflictCoordinatorTests.swift | 18 ++++ .../JotConflictRepositoryTests.swift | 18 ++++ .../JotConflictViewModelTests.swift | 18 ++++ .../JotFileConflictServiceTests.swift | 18 ++++ ...achedJotFilePreviewImageServiceTests.swift | 18 ++++ .../JotsPage/CreateJotCoordinatorTests.swift | 18 ++++ Tests/JotsPage/CreateJotRepositoryTests.swift | 18 ++++ .../JotsPage/DeleteJotCoordinatorTests.swift | 18 ++++ Tests/JotsPage/DeleteJotRepositoryTests.swift | 18 ++++ .../EmptyStateCellViewModelTests.swift | 18 ++++ Tests/JotsPage/JotBusinessModelTests.swift | 18 ++++ Tests/JotsPage/JotCellViewModelTests.swift | 18 ++++ .../JotMenuConfigurationFactoryTests.swift | 18 ++++ Tests/JotsPage/JotsCoordinatorTests.swift | 18 ++++ Tests/JotsPage/JotsRepositoryTests.swift | 18 ++++ Tests/JotsPage/JotsViewModelTests.swift | 18 ++++ .../JotsPage/RenameJotCoordinatorTests.swift | 18 ++++ Tests/JotsPage/RenameJotRepositoryTests.swift | 18 ++++ Tests/JotsPage/ShareJotCoordinatorTests.swift | 18 ++++ Tests/JotsPage/ShareJotRepositoryTests.swift | 18 ++++ Tests/Mocks/ApplicationServiceMock.swift | 18 ++++ Tests/Mocks/BundleServiceMock.swift | 18 ++++ .../Mocks/CloudMigrationCoordinatorMock.swift | 18 ++++ .../Mocks/CloudMigrationRepositoryMock.swift | 18 ++++ ...udMigrationViewControllerFactoryMock.swift | 18 ++++ Tests/Mocks/CoordinatorFactoryMocks.swift | 18 ++++ Tests/Mocks/CoordinatorMock.swift | 18 ++++ Tests/Mocks/CreateJotRepositoryMock.swift | 59 +++++++++++++ Tests/Mocks/DefaultsServiceMock.swift | 18 ++++ Tests/Mocks/DeleteJotRepositoryMock.swift | 36 ++++++++ Tests/Mocks/DeviceServiceMock.swift | 18 ++++ Tests/Mocks/EditJotCoordinatorMock.swift | 18 ++++ Tests/Mocks/EditJotRepositoryMock.swift | 18 ++++ .../EditJotViewControllerFactoryMock.swift | 18 ++++ Tests/Mocks/EnableCloudCoordinatorMock.swift | 18 ++++ ...EnableCloudViewControllerFactoryMock.swift | 18 ++++ Tests/Mocks/FileConflictServiceMock.swift | 18 ++++ Tests/Mocks/FileServiceMock.swift | 18 ++++ Tests/Mocks/JotConflictCoordinatorMock.swift | 18 ++++ Tests/Mocks/JotConflictRepositoryMock.swift | 18 ++++ ...JotConflictViewControllerFactoryMock.swift | 18 ++++ Tests/Mocks/JotFileConflictServiceMock.swift | 18 ++++ .../JotFilePreviewImageServiceMock.swift | 18 ++++ Tests/Mocks/JotFileServiceMock.swift | 18 ++++ Tests/Mocks/JotsCoordinatorMock.swift | 18 ++++ Tests/Mocks/JotsRepositoryMock.swift | 18 ++++ .../Mocks/JotsViewControllerFactoryMock.swift | 18 ++++ Tests/Mocks/PageCoordinatorFactoryMocks.swift | 18 ++++ Tests/Mocks/RenameJotRepositoryMock.swift | 44 ++++++++++ Tests/Mocks/SettingsCoordinatorMock.swift | 18 ++++ Tests/Mocks/SettingsRepositoryMock.swift | 18 ++++ .../SettingsViewControllerFactoryMock.swift | 18 ++++ Tests/Mocks/ShareJotRepositoryMock.swift | 39 +++++++++ .../Mocks/SubCoordinatorRepositoryMocks.swift | 82 ------------------- Tests/Navigation/EditJotURLTests.swift | 18 ++++ .../EnableICloudSupportURLTests.swift | 18 ++++ Tests/Navigation/JotsPageURLTests.swift | 18 ++++ Tests/Navigation/JottreGithubURLTests.swift | 18 ++++ Tests/Navigation/RevealFileURLTests.swift | 18 ++++ ...IOS18SymbolBarButtonItemFactoryTests.swift | 18 ++++ .../IOS18TextBarButtonItemFactoryTests.swift | 18 ++++ .../PageCellSizingStrategyTests.swift | 18 ++++ .../PageHeaderCellViewModelTests.swift | 18 ++++ .../RevealFileCoordinatorTests.swift | 18 ++++ .../SettingsCoordinatorTests.swift | 18 ++++ .../SettingsDropdownCellViewModelTests.swift | 18 ++++ ...ttingsExternalLinkCellViewModelTests.swift | 18 ++++ .../SettingsInfoCellViewModelTests.swift | 18 ++++ .../SettingsRepositoryTests.swift | 18 ++++ .../SettingsToggleCellViewModelTests.swift | 18 ++++ .../SettingsPage/SettingsViewModelTests.swift | 18 ++++ Tests/Utilities/Array+safeIndexTests.swift | 18 ++++ .../AsyncSequenceDebounceTests.swift | 18 ++++ ...ncSequenceToAsyncThrowingStreamTests.swift | 18 ++++ .../NSLayoutConstraintWithPriorityTests.swift | 18 ++++ .../UIColorAdaptiveBlackWhiteTests.swift | 18 ++++ .../Utilities/UIFontPreferredFontTests.swift | 18 ++++ ...aitCollectionHasRenderingChangeTests.swift | 18 ++++ 103 files changed, 1942 insertions(+), 85 deletions(-) create mode 100644 Tests/Mocks/CreateJotRepositoryMock.swift create mode 100644 Tests/Mocks/DeleteJotRepositoryMock.swift create mode 100644 Tests/Mocks/RenameJotRepositoryMock.swift create mode 100644 Tests/Mocks/ShareJotRepositoryMock.swift delete mode 100644 Tests/Mocks/SubCoordinatorRepositoryMocks.swift diff --git a/Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift b/Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift index f55ada8..2272232 100644 --- a/Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift +++ b/Tests/CloudMigrationPage/CloudImageCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre @@ -13,7 +31,6 @@ final class CloudImageCellViewModelTests: XCTestCase { viewModel.handle(action: .tap) // Then - // No-op cell — the only assertion is that handling does not throw. XCTAssertNotNil(viewModel) } } diff --git a/Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift b/Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift index e35a51e..24dff31 100644 --- a/Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift +++ b/Tests/CloudMigrationPage/CloudMigrationCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift b/Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift index 0807bc1..0ba6da8 100644 --- a/Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift +++ b/Tests/CloudMigrationPage/CloudMigrationJotBusinessModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift b/Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift index a677173..b0e2c9a 100644 --- a/Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift +++ b/Tests/CloudMigrationPage/CloudMigrationJotCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift b/Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift index 509f9a4..b7f2f5c 100644 --- a/Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift +++ b/Tests/CloudMigrationPage/CloudMigrationRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift b/Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift index 507f7f3..9b76964 100644 --- a/Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift +++ b/Tests/CloudMigrationPage/CloudMigrationViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Defaults/DefaultsContinuationStorageTests.swift b/Tests/Defaults/DefaultsContinuationStorageTests.swift index 9efeb13..7e56efa 100644 --- a/Tests/Defaults/DefaultsContinuationStorageTests.swift +++ b/Tests/Defaults/DefaultsContinuationStorageTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre @@ -23,7 +41,6 @@ final class DefaultsContinuationStorageTests: XCTestCase { let stream = AsyncStream { continuation in storage.add(continuation, defaultsKey: key) } - // Force the closure to run by creating an iterator. var iterator = stream.makeAsyncIterator() _ = iterator diff --git a/Tests/Defaults/DefaultsKeyTests.swift b/Tests/Defaults/DefaultsKeyTests.swift index 1cf689a..ff95077 100644 --- a/Tests/Defaults/DefaultsKeyTests.swift +++ b/Tests/Defaults/DefaultsKeyTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Defaults/DefaultsServiceTests.swift b/Tests/Defaults/DefaultsServiceTests.swift index 09969c6..3a8f6d1 100644 --- a/Tests/Defaults/DefaultsServiceTests.swift +++ b/Tests/Defaults/DefaultsServiceTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre @@ -77,7 +95,6 @@ final class DefaultsServiceTests: XCTestCase { let key = DefaultsKey("counter") var iterator = service.getValueStream(key).makeAsyncIterator() - // Discard initial yield (nil — no stored value) _ = await iterator.next() // When diff --git a/Tests/EditJotPage/EditJotCoordinatorTests.swift b/Tests/EditJotPage/EditJotCoordinatorTests.swift index fac8dc7..f4a4361 100644 --- a/Tests/EditJotPage/EditJotCoordinatorTests.swift +++ b/Tests/EditJotPage/EditJotCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/EditJotPage/EditJotRepositoryTests.swift b/Tests/EditJotPage/EditJotRepositoryTests.swift index b25e38d..7700840 100644 --- a/Tests/EditJotPage/EditJotRepositoryTests.swift +++ b/Tests/EditJotPage/EditJotRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @preconcurrency import PencilKit import XCTest diff --git a/Tests/EditJotPage/EditJotViewModelTests.swift b/Tests/EditJotPage/EditJotViewModelTests.swift index 3150dee..8a832c1 100644 --- a/Tests/EditJotPage/EditJotViewModelTests.swift +++ b/Tests/EditJotPage/EditJotViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @preconcurrency import PencilKit import XCTest diff --git a/Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift b/Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift index 666edc5..5c73561 100644 --- a/Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift +++ b/Tests/EnableCloudPage/EnableCloudCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/EnableCloudPage/EnableCloudViewModelTests.swift b/Tests/EnableCloudPage/EnableCloudViewModelTests.swift index 8fca48d..4fcf091 100644 --- a/Tests/EnableCloudPage/EnableCloudViewModelTests.swift +++ b/Tests/EnableCloudPage/EnableCloudViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift b/Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift index d048d95..2065b6c 100644 --- a/Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift +++ b/Tests/EnableCloudPage/FeatureRowCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/FileService/LocalFileServiceTests.swift b/Tests/FileService/LocalFileServiceTests.swift index b63132d..a27573d 100644 --- a/Tests/FileService/LocalFileServiceTests.swift +++ b/Tests/FileService/LocalFileServiceTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation import XCTest diff --git a/Tests/FileService/UbiquitousInfoTests.swift b/Tests/FileService/UbiquitousInfoTests.swift index 135c337..51610b4 100644 --- a/Tests/FileService/UbiquitousInfoTests.swift +++ b/Tests/FileService/UbiquitousInfoTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Helpers/Navigation+test.swift b/Tests/Helpers/Navigation+test.swift index 608e8f7..15c030e 100644 --- a/Tests/Helpers/Navigation+test.swift +++ b/Tests/Helpers/Navigation+test.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Helpers/UIAlertAction+invoke.swift b/Tests/Helpers/UIAlertAction+invoke.swift index 5239c73..f90361c 100644 --- a/Tests/Helpers/UIAlertAction+invoke.swift +++ b/Tests/Helpers/UIAlertAction+invoke.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit extension UIAlertAction { diff --git a/Tests/Helpers/URL+staticString.swift b/Tests/Helpers/URL+staticString.swift index c9dd3bd..626dd70 100644 --- a/Tests/Helpers/URL+staticString.swift +++ b/Tests/Helpers/URL+staticString.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation extension URL { diff --git a/Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift b/Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift index 947fad2..83d75a1 100644 --- a/Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift +++ b/Tests/Jot/JotFileServiceDocumentsDirectoryContentsTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation import XCTest diff --git a/Tests/Jot/JotFileServiceTests.swift b/Tests/Jot/JotFileServiceTests.swift index 89aec90..d51fe41 100644 --- a/Tests/Jot/JotFileServiceTests.swift +++ b/Tests/Jot/JotFileServiceTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Jot/JotFileTests.swift b/Tests/Jot/JotFileTests.swift index 5734ec1..64e27d8 100644 --- a/Tests/Jot/JotFileTests.swift +++ b/Tests/Jot/JotFileTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotConflictPage/JotConflictBusinessModelTests.swift b/Tests/JotConflictPage/JotConflictBusinessModelTests.swift index 427a670..385a6a9 100644 --- a/Tests/JotConflictPage/JotConflictBusinessModelTests.swift +++ b/Tests/JotConflictPage/JotConflictBusinessModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotConflictPage/JotConflictCellViewModelTests.swift b/Tests/JotConflictPage/JotConflictCellViewModelTests.swift index 8b2ac91..994bec6 100644 --- a/Tests/JotConflictPage/JotConflictCellViewModelTests.swift +++ b/Tests/JotConflictPage/JotConflictCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotConflictPage/JotConflictCoordinatorTests.swift b/Tests/JotConflictPage/JotConflictCoordinatorTests.swift index 8eb021a..7febd14 100644 --- a/Tests/JotConflictPage/JotConflictCoordinatorTests.swift +++ b/Tests/JotConflictPage/JotConflictCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotConflictPage/JotConflictRepositoryTests.swift b/Tests/JotConflictPage/JotConflictRepositoryTests.swift index 785e062..102b244 100644 --- a/Tests/JotConflictPage/JotConflictRepositoryTests.swift +++ b/Tests/JotConflictPage/JotConflictRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotConflictPage/JotConflictViewModelTests.swift b/Tests/JotConflictPage/JotConflictViewModelTests.swift index 1fc865d..60688dd 100644 --- a/Tests/JotConflictPage/JotConflictViewModelTests.swift +++ b/Tests/JotConflictPage/JotConflictViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotConflictPage/JotFileConflictServiceTests.swift b/Tests/JotConflictPage/JotFileConflictServiceTests.swift index 0848664..4faa46c 100644 --- a/Tests/JotConflictPage/JotFileConflictServiceTests.swift +++ b/Tests/JotConflictPage/JotFileConflictServiceTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift b/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift index 493f473..a6ae4f0 100644 --- a/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift +++ b/Tests/JotFilePreview/CachedJotFilePreviewImageServiceTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/CreateJotCoordinatorTests.swift b/Tests/JotsPage/CreateJotCoordinatorTests.swift index 59f21ce..9633804 100644 --- a/Tests/JotsPage/CreateJotCoordinatorTests.swift +++ b/Tests/JotsPage/CreateJotCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotsPage/CreateJotRepositoryTests.swift b/Tests/JotsPage/CreateJotRepositoryTests.swift index c339163..9923920 100644 --- a/Tests/JotsPage/CreateJotRepositoryTests.swift +++ b/Tests/JotsPage/CreateJotRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/DeleteJotCoordinatorTests.swift b/Tests/JotsPage/DeleteJotCoordinatorTests.swift index ff9bf0a..d5a3bd6 100644 --- a/Tests/JotsPage/DeleteJotCoordinatorTests.swift +++ b/Tests/JotsPage/DeleteJotCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotsPage/DeleteJotRepositoryTests.swift b/Tests/JotsPage/DeleteJotRepositoryTests.swift index 61e53bd..d9e220d 100644 --- a/Tests/JotsPage/DeleteJotRepositoryTests.swift +++ b/Tests/JotsPage/DeleteJotRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/EmptyStateCellViewModelTests.swift b/Tests/JotsPage/EmptyStateCellViewModelTests.swift index 2e6dfbc..8f7f0ec 100644 --- a/Tests/JotsPage/EmptyStateCellViewModelTests.swift +++ b/Tests/JotsPage/EmptyStateCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/JotBusinessModelTests.swift b/Tests/JotsPage/JotBusinessModelTests.swift index e46c311..bd788d3 100644 --- a/Tests/JotsPage/JotBusinessModelTests.swift +++ b/Tests/JotsPage/JotBusinessModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/JotCellViewModelTests.swift b/Tests/JotsPage/JotCellViewModelTests.swift index 89cac39..32a7589 100644 --- a/Tests/JotsPage/JotCellViewModelTests.swift +++ b/Tests/JotsPage/JotCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotsPage/JotMenuConfigurationFactoryTests.swift b/Tests/JotsPage/JotMenuConfigurationFactoryTests.swift index 3002897..fde30cc 100644 --- a/Tests/JotsPage/JotMenuConfigurationFactoryTests.swift +++ b/Tests/JotsPage/JotMenuConfigurationFactoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/JotsCoordinatorTests.swift b/Tests/JotsPage/JotsCoordinatorTests.swift index bdac0d9..27af9f1 100644 --- a/Tests/JotsPage/JotsCoordinatorTests.swift +++ b/Tests/JotsPage/JotsCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotsPage/JotsRepositoryTests.swift b/Tests/JotsPage/JotsRepositoryTests.swift index 39b58c8..014802d 100644 --- a/Tests/JotsPage/JotsRepositoryTests.swift +++ b/Tests/JotsPage/JotsRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/JotsViewModelTests.swift b/Tests/JotsPage/JotsViewModelTests.swift index 5fb28b5..7c1f6f3 100644 --- a/Tests/JotsPage/JotsViewModelTests.swift +++ b/Tests/JotsPage/JotsViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/RenameJotCoordinatorTests.swift b/Tests/JotsPage/RenameJotCoordinatorTests.swift index 65986dc..2c04621 100644 --- a/Tests/JotsPage/RenameJotCoordinatorTests.swift +++ b/Tests/JotsPage/RenameJotCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotsPage/RenameJotRepositoryTests.swift b/Tests/JotsPage/RenameJotRepositoryTests.swift index 3569139..a0782ee 100644 --- a/Tests/JotsPage/RenameJotRepositoryTests.swift +++ b/Tests/JotsPage/RenameJotRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/JotsPage/ShareJotCoordinatorTests.swift b/Tests/JotsPage/ShareJotCoordinatorTests.swift index a7ab344..b6db5b1 100644 --- a/Tests/JotsPage/ShareJotCoordinatorTests.swift +++ b/Tests/JotsPage/ShareJotCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/JotsPage/ShareJotRepositoryTests.swift b/Tests/JotsPage/ShareJotRepositoryTests.swift index 1470c7b..7c66c2b 100644 --- a/Tests/JotsPage/ShareJotRepositoryTests.swift +++ b/Tests/JotsPage/ShareJotRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @preconcurrency import PencilKit import UIKit import XCTest diff --git a/Tests/Mocks/ApplicationServiceMock.swift b/Tests/Mocks/ApplicationServiceMock.swift index c012c6f..99333f9 100644 --- a/Tests/Mocks/ApplicationServiceMock.swift +++ b/Tests/Mocks/ApplicationServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation @testable import Jottre diff --git a/Tests/Mocks/BundleServiceMock.swift b/Tests/Mocks/BundleServiceMock.swift index 9e510bc..b52302f 100644 --- a/Tests/Mocks/BundleServiceMock.swift +++ b/Tests/Mocks/BundleServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @testable import Jottre final class BundleServiceMock: BundleServiceProtocol { diff --git a/Tests/Mocks/CloudMigrationCoordinatorMock.swift b/Tests/Mocks/CloudMigrationCoordinatorMock.swift index 12bfdda..1df724c 100644 --- a/Tests/Mocks/CloudMigrationCoordinatorMock.swift +++ b/Tests/Mocks/CloudMigrationCoordinatorMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @testable import Jottre @MainActor diff --git a/Tests/Mocks/CloudMigrationRepositoryMock.swift b/Tests/Mocks/CloudMigrationRepositoryMock.swift index ea675c0..b7f759c 100644 --- a/Tests/Mocks/CloudMigrationRepositoryMock.swift +++ b/Tests/Mocks/CloudMigrationRepositoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation import UIKit diff --git a/Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift b/Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift index e5274b6..dcf082f 100644 --- a/Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift +++ b/Tests/Mocks/CloudMigrationViewControllerFactoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/CoordinatorFactoryMocks.swift b/Tests/Mocks/CoordinatorFactoryMocks.swift index abe0be9..8dcc111 100644 --- a/Tests/Mocks/CoordinatorFactoryMocks.swift +++ b/Tests/Mocks/CoordinatorFactoryMocks.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation @testable import Jottre diff --git a/Tests/Mocks/CoordinatorMock.swift b/Tests/Mocks/CoordinatorMock.swift index d6fa39b..f17bbb8 100644 --- a/Tests/Mocks/CoordinatorMock.swift +++ b/Tests/Mocks/CoordinatorMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @testable import Jottre @MainActor diff --git a/Tests/Mocks/CreateJotRepositoryMock.swift b/Tests/Mocks/CreateJotRepositoryMock.swift new file mode 100644 index 0000000..bc5030a --- /dev/null +++ b/Tests/Mocks/CreateJotRepositoryMock.swift @@ -0,0 +1,59 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +import Foundation + +@testable import Jottre + +final class CreateJotRepositoryMock: CreateJotRepositoryProtocol { + + private let createJotProvider: @Sendable (_ name: String) async throws -> JotFile.Info + + init( + createJotProvider: + @Sendable @escaping (_ name: String) async throws -> JotFile.Info = { name in + JotFile.Info( + url: URL(fileURLWithPath: "/tmp/\(name).jot"), + name: name, + modificationDate: nil, + ubiquitousInfo: nil + ) + } + ) { + self.createJotProvider = createJotProvider + } + + func createJot(name: String) async throws -> JotFile.Info { + try await createJotProvider(name) + } +} + +final class DeleteJotRepositoryMock: DeleteJotRepositoryProtocol { + + private let deleteJotProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> Void + + init( + deleteJotProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> Void = { _ in } + ) { + self.deleteJotProvider = deleteJotProvider + } + + func deleteJot(jotFileInfo: JotFile.Info) throws { + try deleteJotProvider(jotFileInfo) + } +} diff --git a/Tests/Mocks/DefaultsServiceMock.swift b/Tests/Mocks/DefaultsServiceMock.swift index d0a9916..773bd3e 100644 --- a/Tests/Mocks/DefaultsServiceMock.swift +++ b/Tests/Mocks/DefaultsServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation @testable import Jottre diff --git a/Tests/Mocks/DeleteJotRepositoryMock.swift b/Tests/Mocks/DeleteJotRepositoryMock.swift new file mode 100644 index 0000000..af087d2 --- /dev/null +++ b/Tests/Mocks/DeleteJotRepositoryMock.swift @@ -0,0 +1,36 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +import Foundation + +@testable import Jottre + +final class DeleteJotRepositoryMock: DeleteJotRepositoryProtocol { + + private let deleteJotProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> Void + + init( + deleteJotProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> Void = { _ in } + ) { + self.deleteJotProvider = deleteJotProvider + } + + func deleteJot(jotFileInfo: JotFile.Info) throws { + try deleteJotProvider(jotFileInfo) + } +} diff --git a/Tests/Mocks/DeviceServiceMock.swift b/Tests/Mocks/DeviceServiceMock.swift index ae25289..ee083e3 100644 --- a/Tests/Mocks/DeviceServiceMock.swift +++ b/Tests/Mocks/DeviceServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @testable import Jottre @MainActor diff --git a/Tests/Mocks/EditJotCoordinatorMock.swift b/Tests/Mocks/EditJotCoordinatorMock.swift index 1981e95..d51af04 100644 --- a/Tests/Mocks/EditJotCoordinatorMock.swift +++ b/Tests/Mocks/EditJotCoordinatorMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/EditJotRepositoryMock.swift b/Tests/Mocks/EditJotRepositoryMock.swift index 8faea36..5023d9c 100644 --- a/Tests/Mocks/EditJotRepositoryMock.swift +++ b/Tests/Mocks/EditJotRepositoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import CoreGraphics import Foundation @preconcurrency import PencilKit diff --git a/Tests/Mocks/EditJotViewControllerFactoryMock.swift b/Tests/Mocks/EditJotViewControllerFactoryMock.swift index adb77fc..03f2027 100644 --- a/Tests/Mocks/EditJotViewControllerFactoryMock.swift +++ b/Tests/Mocks/EditJotViewControllerFactoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/EnableCloudCoordinatorMock.swift b/Tests/Mocks/EnableCloudCoordinatorMock.swift index 0f36b89..a69011c 100644 --- a/Tests/Mocks/EnableCloudCoordinatorMock.swift +++ b/Tests/Mocks/EnableCloudCoordinatorMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @testable import Jottre @MainActor diff --git a/Tests/Mocks/EnableCloudViewControllerFactoryMock.swift b/Tests/Mocks/EnableCloudViewControllerFactoryMock.swift index c719438..220f083 100644 --- a/Tests/Mocks/EnableCloudViewControllerFactoryMock.swift +++ b/Tests/Mocks/EnableCloudViewControllerFactoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/FileConflictServiceMock.swift b/Tests/Mocks/FileConflictServiceMock.swift index 3748606..9787476 100644 --- a/Tests/Mocks/FileConflictServiceMock.swift +++ b/Tests/Mocks/FileConflictServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation @testable import Jottre diff --git a/Tests/Mocks/FileServiceMock.swift b/Tests/Mocks/FileServiceMock.swift index 7e64829..118297b 100644 --- a/Tests/Mocks/FileServiceMock.swift +++ b/Tests/Mocks/FileServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation @testable import Jottre diff --git a/Tests/Mocks/JotConflictCoordinatorMock.swift b/Tests/Mocks/JotConflictCoordinatorMock.swift index ee43de2..03b68a1 100644 --- a/Tests/Mocks/JotConflictCoordinatorMock.swift +++ b/Tests/Mocks/JotConflictCoordinatorMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @testable import Jottre @MainActor diff --git a/Tests/Mocks/JotConflictRepositoryMock.swift b/Tests/Mocks/JotConflictRepositoryMock.swift index 0b805fd..4cdf2c0 100644 --- a/Tests/Mocks/JotConflictRepositoryMock.swift +++ b/Tests/Mocks/JotConflictRepositoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation import UIKit diff --git a/Tests/Mocks/JotConflictViewControllerFactoryMock.swift b/Tests/Mocks/JotConflictViewControllerFactoryMock.swift index a655e94..4788cba 100644 --- a/Tests/Mocks/JotConflictViewControllerFactoryMock.swift +++ b/Tests/Mocks/JotConflictViewControllerFactoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/JotFileConflictServiceMock.swift b/Tests/Mocks/JotFileConflictServiceMock.swift index 59915e0..43e0ff4 100644 --- a/Tests/Mocks/JotFileConflictServiceMock.swift +++ b/Tests/Mocks/JotFileConflictServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + @testable import Jottre final class JotFileConflictServiceMock: JotFileConflictServiceProtocol { diff --git a/Tests/Mocks/JotFilePreviewImageServiceMock.swift b/Tests/Mocks/JotFilePreviewImageServiceMock.swift index 8536eac..8c64a0d 100644 --- a/Tests/Mocks/JotFilePreviewImageServiceMock.swift +++ b/Tests/Mocks/JotFilePreviewImageServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation import UIKit diff --git a/Tests/Mocks/JotFileServiceMock.swift b/Tests/Mocks/JotFileServiceMock.swift index 663013c..d085d7e 100644 --- a/Tests/Mocks/JotFileServiceMock.swift +++ b/Tests/Mocks/JotFileServiceMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation @testable import Jottre diff --git a/Tests/Mocks/JotsCoordinatorMock.swift b/Tests/Mocks/JotsCoordinatorMock.swift index db75b05..a93a392 100644 --- a/Tests/Mocks/JotsCoordinatorMock.swift +++ b/Tests/Mocks/JotsCoordinatorMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/JotsRepositoryMock.swift b/Tests/Mocks/JotsRepositoryMock.swift index 0b0d864..96af65d 100644 --- a/Tests/Mocks/JotsRepositoryMock.swift +++ b/Tests/Mocks/JotsRepositoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation import UIKit diff --git a/Tests/Mocks/JotsViewControllerFactoryMock.swift b/Tests/Mocks/JotsViewControllerFactoryMock.swift index 004f267..27c545f 100644 --- a/Tests/Mocks/JotsViewControllerFactoryMock.swift +++ b/Tests/Mocks/JotsViewControllerFactoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/PageCoordinatorFactoryMocks.swift b/Tests/Mocks/PageCoordinatorFactoryMocks.swift index 94928e5..b9edb0e 100644 --- a/Tests/Mocks/PageCoordinatorFactoryMocks.swift +++ b/Tests/Mocks/PageCoordinatorFactoryMocks.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/RenameJotRepositoryMock.swift b/Tests/Mocks/RenameJotRepositoryMock.swift new file mode 100644 index 0000000..a03a520 --- /dev/null +++ b/Tests/Mocks/RenameJotRepositoryMock.swift @@ -0,0 +1,44 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +import Foundation + +@testable import Jottre + +final class RenameJotRepositoryMock: RenameJotRepositoryProtocol { + + private let renameProvider: (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info + + init( + renameProvider: + @escaping (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info = { jotFileInfo, name in + JotFile.Info( + url: jotFileInfo.url.deletingLastPathComponent().appendingPathComponent("\(name).jot"), + name: name, + modificationDate: nil, + ubiquitousInfo: nil + ) + } + ) { + self.renameProvider = renameProvider + } + + func rename(jotFileInfo: JotFile.Info, newName: String) throws -> JotFile.Info { + try renameProvider(jotFileInfo, newName) + } +} diff --git a/Tests/Mocks/SettingsCoordinatorMock.swift b/Tests/Mocks/SettingsCoordinatorMock.swift index 762bca2..9c426c6 100644 --- a/Tests/Mocks/SettingsCoordinatorMock.swift +++ b/Tests/Mocks/SettingsCoordinatorMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import Foundation @testable import Jottre diff --git a/Tests/Mocks/SettingsRepositoryMock.swift b/Tests/Mocks/SettingsRepositoryMock.swift index 821c7e3..b843bf5 100644 --- a/Tests/Mocks/SettingsRepositoryMock.swift +++ b/Tests/Mocks/SettingsRepositoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/SettingsViewControllerFactoryMock.swift b/Tests/Mocks/SettingsViewControllerFactoryMock.swift index 44f0269..d8d596a 100644 --- a/Tests/Mocks/SettingsViewControllerFactoryMock.swift +++ b/Tests/Mocks/SettingsViewControllerFactoryMock.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit @testable import Jottre diff --git a/Tests/Mocks/ShareJotRepositoryMock.swift b/Tests/Mocks/ShareJotRepositoryMock.swift new file mode 100644 index 0000000..3039522 --- /dev/null +++ b/Tests/Mocks/ShareJotRepositoryMock.swift @@ -0,0 +1,39 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +import Foundation + +@testable import Jottre + +final class ShareJotRepositoryMock: ShareJotRepositoryProtocol { + + private let exportJotProvider: @Sendable (_ jotFileInfo: JotFile.Info, _ format: ShareFormat) async throws -> URL + + init( + exportJotProvider: + @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ format: ShareFormat) async throws -> URL = { _, _ in + URL(fileURLWithPath: "/tmp/share") + } + ) { + self.exportJotProvider = exportJotProvider + } + + func exportJot(jotFileInfo: JotFile.Info, format: ShareFormat) async throws -> URL { + try await exportJotProvider(jotFileInfo, format) + } +} diff --git a/Tests/Mocks/SubCoordinatorRepositoryMocks.swift b/Tests/Mocks/SubCoordinatorRepositoryMocks.swift deleted file mode 100644 index 5500f35..0000000 --- a/Tests/Mocks/SubCoordinatorRepositoryMocks.swift +++ /dev/null @@ -1,82 +0,0 @@ -import Foundation - -@testable import Jottre - -final class CreateJotRepositoryMock: CreateJotRepositoryProtocol { - - private let createJotProvider: @Sendable (_ name: String) async throws -> JotFile.Info - - init( - createJotProvider: - @Sendable @escaping (_ name: String) async throws -> JotFile.Info = { name in - JotFile.Info( - url: URL(fileURLWithPath: "/tmp/\(name).jot"), - name: name, - modificationDate: nil, - ubiquitousInfo: nil - ) - } - ) { - self.createJotProvider = createJotProvider - } - - func createJot(name: String) async throws -> JotFile.Info { - try await createJotProvider(name) - } -} - -final class DeleteJotRepositoryMock: DeleteJotRepositoryProtocol { - - private let deleteJotProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> Void - - init( - deleteJotProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> Void = { _ in } - ) { - self.deleteJotProvider = deleteJotProvider - } - - func deleteJot(jotFileInfo: JotFile.Info) throws { - try deleteJotProvider(jotFileInfo) - } -} - -final class RenameJotRepositoryMock: RenameJotRepositoryProtocol { - - private let renameProvider: (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info - - init( - renameProvider: - @escaping (_ jotFileInfo: JotFile.Info, _ newName: String) throws -> JotFile.Info = { jotFileInfo, name in - JotFile.Info( - url: jotFileInfo.url.deletingLastPathComponent().appendingPathComponent("\(name).jot"), - name: name, - modificationDate: nil, - ubiquitousInfo: nil - ) - } - ) { - self.renameProvider = renameProvider - } - - func rename(jotFileInfo: JotFile.Info, newName: String) throws -> JotFile.Info { - try renameProvider(jotFileInfo, newName) - } -} - -final class ShareJotRepositoryMock: ShareJotRepositoryProtocol { - - private let exportJotProvider: @Sendable (_ jotFileInfo: JotFile.Info, _ format: ShareFormat) async throws -> URL - - init( - exportJotProvider: - @Sendable @escaping (_ jotFileInfo: JotFile.Info, _ format: ShareFormat) async throws -> URL = { _, _ in - URL(fileURLWithPath: "/tmp/share") - } - ) { - self.exportJotProvider = exportJotProvider - } - - func exportJot(jotFileInfo: JotFile.Info, format: ShareFormat) async throws -> URL { - try await exportJotProvider(jotFileInfo, format) - } -} diff --git a/Tests/Navigation/EditJotURLTests.swift b/Tests/Navigation/EditJotURLTests.swift index 60c7916..95954fd 100644 --- a/Tests/Navigation/EditJotURLTests.swift +++ b/Tests/Navigation/EditJotURLTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Navigation/EnableICloudSupportURLTests.swift b/Tests/Navigation/EnableICloudSupportURLTests.swift index a8067a0..9a41bd5 100644 --- a/Tests/Navigation/EnableICloudSupportURLTests.swift +++ b/Tests/Navigation/EnableICloudSupportURLTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Navigation/JotsPageURLTests.swift b/Tests/Navigation/JotsPageURLTests.swift index 6e7cc13..84935aa 100644 --- a/Tests/Navigation/JotsPageURLTests.swift +++ b/Tests/Navigation/JotsPageURLTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Navigation/JottreGithubURLTests.swift b/Tests/Navigation/JottreGithubURLTests.swift index ddab2fc..5a15237 100644 --- a/Tests/Navigation/JottreGithubURLTests.swift +++ b/Tests/Navigation/JottreGithubURLTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Navigation/RevealFileURLTests.swift b/Tests/Navigation/RevealFileURLTests.swift index aae7450..d75311c 100644 --- a/Tests/Navigation/RevealFileURLTests.swift +++ b/Tests/Navigation/RevealFileURLTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift b/Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift index 8a69c55..15056d6 100644 --- a/Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift +++ b/Tests/PageViewController/IOS18SymbolBarButtonItemFactoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift b/Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift index 8ff789d..94993b5 100644 --- a/Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift +++ b/Tests/PageViewController/IOS18TextBarButtonItemFactoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/PageViewController/PageCellSizingStrategyTests.swift b/Tests/PageViewController/PageCellSizingStrategyTests.swift index bfc22fa..3829fb0 100644 --- a/Tests/PageViewController/PageCellSizingStrategyTests.swift +++ b/Tests/PageViewController/PageCellSizingStrategyTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/PageViewController/PageHeaderCellViewModelTests.swift b/Tests/PageViewController/PageHeaderCellViewModelTests.swift index 90e0e82..b5d29e7 100644 --- a/Tests/PageViewController/PageHeaderCellViewModelTests.swift +++ b/Tests/PageViewController/PageHeaderCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/RevealFile/RevealFileCoordinatorTests.swift b/Tests/RevealFile/RevealFileCoordinatorTests.swift index b17a4b4..8afad00 100644 --- a/Tests/RevealFile/RevealFileCoordinatorTests.swift +++ b/Tests/RevealFile/RevealFileCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/SettingsPage/SettingsCoordinatorTests.swift b/Tests/SettingsPage/SettingsCoordinatorTests.swift index 9af7e80..6902289 100644 --- a/Tests/SettingsPage/SettingsCoordinatorTests.swift +++ b/Tests/SettingsPage/SettingsCoordinatorTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift b/Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift index 50d8411..9cb50a5 100644 --- a/Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift +++ b/Tests/SettingsPage/SettingsDropdownCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift b/Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift index a7d0ce4..a8ff5dd 100644 --- a/Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift +++ b/Tests/SettingsPage/SettingsExternalLinkCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/SettingsPage/SettingsInfoCellViewModelTests.swift b/Tests/SettingsPage/SettingsInfoCellViewModelTests.swift index b9175d8..6d91786 100644 --- a/Tests/SettingsPage/SettingsInfoCellViewModelTests.swift +++ b/Tests/SettingsPage/SettingsInfoCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/SettingsPage/SettingsRepositoryTests.swift b/Tests/SettingsPage/SettingsRepositoryTests.swift index 30292c5..193ca2f 100644 --- a/Tests/SettingsPage/SettingsRepositoryTests.swift +++ b/Tests/SettingsPage/SettingsRepositoryTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/SettingsPage/SettingsToggleCellViewModelTests.swift b/Tests/SettingsPage/SettingsToggleCellViewModelTests.swift index 9aefc6a..b63403f 100644 --- a/Tests/SettingsPage/SettingsToggleCellViewModelTests.swift +++ b/Tests/SettingsPage/SettingsToggleCellViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/SettingsPage/SettingsViewModelTests.swift b/Tests/SettingsPage/SettingsViewModelTests.swift index b50a3dd..2c9a31b 100644 --- a/Tests/SettingsPage/SettingsViewModelTests.swift +++ b/Tests/SettingsPage/SettingsViewModelTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/Utilities/Array+safeIndexTests.swift b/Tests/Utilities/Array+safeIndexTests.swift index c9b7f15..a606154 100644 --- a/Tests/Utilities/Array+safeIndexTests.swift +++ b/Tests/Utilities/Array+safeIndexTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Utilities/AsyncSequenceDebounceTests.swift b/Tests/Utilities/AsyncSequenceDebounceTests.swift index 20e1f53..ee32940 100644 --- a/Tests/Utilities/AsyncSequenceDebounceTests.swift +++ b/Tests/Utilities/AsyncSequenceDebounceTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift b/Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift index 6683398..b752a5b 100644 --- a/Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift +++ b/Tests/Utilities/AsyncSequenceToAsyncThrowingStreamTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import XCTest @testable import Jottre diff --git a/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift b/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift index ecde69d..3a29db4 100644 --- a/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift +++ b/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift b/Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift index dad4b0a..894e04f 100644 --- a/Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift +++ b/Tests/Utilities/UIColorAdaptiveBlackWhiteTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/Utilities/UIFontPreferredFontTests.swift b/Tests/Utilities/UIFontPreferredFontTests.swift index f26cfe4..f6307a8 100644 --- a/Tests/Utilities/UIFontPreferredFontTests.swift +++ b/Tests/Utilities/UIFontPreferredFontTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest diff --git a/Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift b/Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift index 151418c..97c5f10 100644 --- a/Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift +++ b/Tests/Utilities/UITraitCollectionHasRenderingChangeTests.swift @@ -1,3 +1,21 @@ +/* + Jottre: Minimalistic jotting for iPhone, iPad and Mac. + Copyright (C) 2021-2026 Anton Lorani + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + import UIKit import XCTest From c73ced6044eba55bcb2a9f31bf16c1d03b47195e Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Sat, 9 May 2026 11:15:18 +0200 Subject: [PATCH 7/9] Ignore test resources from license header checks (#124) --- .licenseignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.licenseignore b/.licenseignore index 10ece98..ce6ea79 100644 --- a/.licenseignore +++ b/.licenseignore @@ -9,6 +9,7 @@ README.md *.jpg Jottre.xcodeproj Resources +Tests/Resources hooks fastlane Gemfile From 8efb0c159ba0c27485dcb02befa6e55a3e96c983 Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Sat, 9 May 2026 11:19:18 +0200 Subject: [PATCH 8/9] Dedup mock type (#124) --- Tests/Mocks/CreateJotRepositoryMock.swift | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/Tests/Mocks/CreateJotRepositoryMock.swift b/Tests/Mocks/CreateJotRepositoryMock.swift index bc5030a..7d5f151 100644 --- a/Tests/Mocks/CreateJotRepositoryMock.swift +++ b/Tests/Mocks/CreateJotRepositoryMock.swift @@ -42,18 +42,3 @@ final class CreateJotRepositoryMock: CreateJotRepositoryProtocol { try await createJotProvider(name) } } - -final class DeleteJotRepositoryMock: DeleteJotRepositoryProtocol { - - private let deleteJotProvider: @Sendable (_ jotFileInfo: JotFile.Info) throws -> Void - - init( - deleteJotProvider: @Sendable @escaping (_ jotFileInfo: JotFile.Info) throws -> Void = { _ in } - ) { - self.deleteJotProvider = deleteJotProvider - } - - func deleteJot(jotFileInfo: JotFile.Info) throws { - try deleteJotProvider(jotFileInfo) - } -} From f18cefd6f5e8306cc3a8e890ae9f6255464bd509 Mon Sep 17 00:00:00 2001 From: Anton Lorani <28454919+antonlorani@users.noreply.github.com> Date: Sat, 9 May 2026 11:31:26 +0200 Subject: [PATCH 9/9] Suppress warnings (#124) --- Tests/Defaults/DefaultsContinuationStorageTests.swift | 8 ++++---- Tests/FileService/LocalFileServiceTests.swift | 2 +- Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift | 1 + 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/Tests/Defaults/DefaultsContinuationStorageTests.swift b/Tests/Defaults/DefaultsContinuationStorageTests.swift index 7e56efa..55a839e 100644 --- a/Tests/Defaults/DefaultsContinuationStorageTests.swift +++ b/Tests/Defaults/DefaultsContinuationStorageTests.swift @@ -41,7 +41,7 @@ final class DefaultsContinuationStorageTests: XCTestCase { let stream = AsyncStream { continuation in storage.add(continuation, defaultsKey: key) } - var iterator = stream.makeAsyncIterator() + let iterator = stream.makeAsyncIterator() _ = iterator // When @@ -61,8 +61,8 @@ final class DefaultsContinuationStorageTests: XCTestCase { let stream2 = AsyncStream { continuation in storage.add(continuation, defaultsKey: key) } - var iterator1 = stream1.makeAsyncIterator() - var iterator2 = stream2.makeAsyncIterator() + let iterator1 = stream1.makeAsyncIterator() + let iterator2 = stream2.makeAsyncIterator() _ = iterator1 _ = iterator2 @@ -81,7 +81,7 @@ final class DefaultsContinuationStorageTests: XCTestCase { let stream = AsyncStream { continuation in storage.add(continuation, defaultsKey: registeredKey) } - var iterator = stream.makeAsyncIterator() + let iterator = stream.makeAsyncIterator() _ = iterator // When diff --git a/Tests/FileService/LocalFileServiceTests.swift b/Tests/FileService/LocalFileServiceTests.swift index a27573d..dabb350 100644 --- a/Tests/FileService/LocalFileServiceTests.swift +++ b/Tests/FileService/LocalFileServiceTests.swift @@ -162,7 +162,7 @@ final class LocalFileServiceTests: XCTestCase { var iterator = stream.makeAsyncIterator() // When - let first = await iterator.next() + let first: Void? = await iterator.next() // Then XCTAssertNotNil(first) diff --git a/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift b/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift index 3a29db4..2c8b97b 100644 --- a/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift +++ b/Tests/Utilities/NSLayoutConstraintWithPriorityTests.swift @@ -21,6 +21,7 @@ import XCTest @testable import Jottre +@MainActor final class NSLayoutConstraintWithPriorityTests: XCTestCase { func test_withPriority_setsPriorityAndReturnsSameConstraint() {

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 LVw{7C0ue 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