Backfill more tests

Author: alicerunsonfedora

MCMaps/Shared/Services/CartographyIntegrationService.swift

@@ -6,6 +6,7 @@
 //
 
 import CubiomesKit
+import Foundation
 import MCMap
 import os
 
@@ -90,7 +91,7 @@ actor CartographyIntegrationService {
     }
 
     /// An enumeration of the errors that the service can throw when attempting to make requests.
-    enum ServiceError: Error {
+    enum ServiceError: Equatable, Error {
         /// The integration is disabled.
         case integrationDisabled
 
@@ -102,6 +103,19 @@ actor CartographyIntegrationService {
         /// The fetch task failed.
         /// - Parameter error: The error that was thrown by the task.
         case fetchTaskFailed(Error)
+
+        static func == (lhs: ServiceError, rhs: ServiceError) -> Bool {
+            switch (lhs, rhs) {
+            case (.integrationDisabled, .integrationDisabled):
+                return true
+            case (.mismatchingService, .mismatchingService):
+                return true
+            case let (.fetchTaskFailed(lhsErr), .fetchTaskFailed(rhsErr)):
+                return lhsErr.localizedDescription == rhsErr.localizedDescription
+            default:
+                return false
+            }
+        }
     }
 
     /// The integration settings used to configure the service.
@@ -116,12 +130,16 @@ actor CartographyIntegrationService {
     /// Initialize a service of a given type with integration settings.
     /// - Parameter serviceType: The service type to use with the integration service.
     /// - Parameter integrationSettings: The settings for integrations used to configure this service.
-    init(serviceType: ServiceType, integrationSettings: CartographyMapFile.Integrations) {
+    init(
+        serviceType: ServiceType,
+        integrationSettings: CartographyMapFile.Integrations,
+        session: any NetworkServiceable = URLSession(configuration: .default)
+    ) {
         self.serviceType = serviceType
         self.integrationSettings = integrationSettings
         switch serviceType {
         case .bluemap:
-            self.service = CartographyBluemapService(withConfiguration: integrationSettings.bluemap)
+            self.service = CartographyBluemapService(withConfiguration: integrationSettings.bluemap, session: session)
         }
     }
 

MCMapsTests/BluemapResultsTests.swift

@@ -0,0 +1,98 @@
+//
+//  BluemapResultsTests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 05-08-2025.
+//
+
+import CubiomesKit
+import MCMap
+import SwiftUI
+import Testing
+
+@testable import Alidade
+
+struct BluemapResultsTests {
+    @Test func isEmpty() async throws {
+        let bluemapResults = BluemapResults()
+        #expect(bluemapResults.isEmpty)
+    }
+
+    @Test func merged() async throws {
+        let id = UUID()
+        let original = BluemapResults()
+        let newContent = BluemapResults(
+            players: BluemapPlayerResponse(players: [
+                BluemapPlayer(
+                    uuid: id,
+                    name: "lweiss",
+                    foreign: false,
+                    position: BluemapPosition(x: 10, y: 10, z: 10),
+                    rotation: BluemapPlayer.Rotation(pitch: 0, yaw: 0, roll: 0)
+                )
+            ]))
+
+        let merged = original.merged(with: newContent)
+        #expect(merged.players != nil)
+        #expect(merged.markers == nil)
+    }
+
+    @Test func annotations() async throws {
+        let uuid = UUID()
+        let results = BluemapResults(
+            markers: [
+                "foo": BluemapMarkerAnnotationGroup(
+                    label: "Foo",
+                    toggleable: true,
+                    defaultHidden: false,
+                    sorting: 0,
+                    markers: [
+                        "mymarker": BluemapMarkerAnnotation(
+                            classes: [""],
+                            label: "My Marker",
+                            position: BluemapPosition(x: 0, y: 0, z: 0),
+                            minDistance: 0,
+                            maxDistance: .greatestFiniteMagnitude,
+                            type: "poi",
+                            sorting: 0,
+                            listed: true
+                        )
+                    ]
+                )
+            ],
+            players: BluemapPlayerResponse(
+                players: [
+                    BluemapPlayer(
+                        uuid: uuid,
+                        name: "lweiss",
+                        foreign: false,
+                        position: BluemapPosition(x: 10, y: 10, z: 10),
+                        rotation: BluemapPlayer.Rotation(pitch: 0, yaw: 0, roll: 0)
+                    )
+                ]
+            )
+        )
+
+        let annotations = results.annotations(
+            from: MCMapBluemapIntegration(
+                baseURL: "https://example.com",
+                enabled: true
+            )
+        )
+        #expect(annotations.count == 2)
+
+        let first = try #require(annotations.last as? Marker)
+        #expect(
+            first
+                == Marker(
+                    location: .zero,
+                    title: "My Marker",
+                    id: "mymarker",
+                    clusterIdentifier: "bmap-server-marker"
+                )
+        )
+
+        let last = try #require(annotations.first as? PlayerMarker)
+        #expect(last == PlayerMarker(location: CGPoint(x: 10, y: 10), name: "lweiss", playerUUID: uuid))
+    }
+}

MCMapsTests/CartographyGalleryWindowContextTests.swift

@@ -0,0 +1,33 @@
+//
+//  CartographyGalleryWindowContextTests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 05-08-2025.
+//
+
+import Foundation
+import MCMap
+import Testing
+
+@testable import Alidade
+
+struct CartographyGalleryWindowContextTests {
+    @Test func empty() async throws {
+        let emptyContext = CartographyGalleryWindowContext.empty()
+        #expect(emptyContext.imageCollection.isEmpty)
+        #expect(emptyContext.documentBaseURL == nil)
+    }
+
+    @Test func initFromFile() async throws {
+        let file = CartographyMapFile(
+            withManifest: MCMapManifest_v2(
+                name: "My World",
+                worldSettings: MCMapManifestWorldSettings(version: "1.21", seed: 123),
+                pins: []
+            ),
+            images: ["example": Data()]
+        )
+        let context = CartographyGalleryWindowContext(file: file, documentBaseURL: nil)
+        #expect(!context.imageCollection.isEmpty)
+    }
+}

MCMapsTests/Services/CartographyIntegrationServiceTests.swift

@@ -0,0 +1,63 @@
+//
+//  CartographyIntegrationServiceTests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 05-08-2025.
+//
+
+import Foundation
+import MCMap
+import Testing
+
+@testable import Alidade
+
+struct CartographyIntegrationServiceTests {
+    let service = MockNetworkServicable()
+    let sampleFile = CartographyMapFile(withManifest: .sampleFile)
+
+    var integration: CartographyMapFile.Integrations {
+        var original = sampleFile.integrations
+        original.bluemap.baseURL = "bluemap.augenwaldburg.tld"
+        original.bluemap.enabled = true
+        original.bluemap.realtime = true
+        original.bluemap.mapping.overworld = "world"
+        return original
+    }
+
+    @Test func syncNoopWhenDisabled() async throws {
+        var disabled = integration
+        disabled.bluemap.enabled = false
+
+        let service = CartographyIntegrationService(
+            serviceType: .bluemap,
+            integrationSettings: disabled,
+            session: service
+        )
+
+        await #expect(throws: CartographyIntegrationService.ServiceError.integrationDisabled) {
+            let _: BluemapResults? = try await service.sync(dimension: .overworld)
+        }
+    }
+
+    @Test func bluemapRegularSync() async throws {
+        let service = CartographyIntegrationService(
+            serviceType: .bluemap,
+            integrationSettings: integration,
+            session: service
+        )
+        let response: BluemapResults? = try await service.sync(dimension: .overworld, syncType: .regular)
+        #expect(response?.isEmpty == false)
+    }
+
+    @Test func bluemapRealtimeSync() async throws {
+        let service = CartographyIntegrationService(
+            serviceType: .bluemap,
+            integrationSettings: integration,
+            session: service
+        )
+        let response: BluemapResults? = try await service.sync(dimension: .overworld, syncType: .realtime)
+        #expect(response?.isEmpty == false)
+        #expect(response?.markers == nil)
+        #expect(response?.players != nil)
+    }
+}