397 lines
12 KiB
Swift
397 lines
12 KiB
Swift
// ===----------------------------------------------------------------------===
|
|
//
|
|
// This source file is part of the Amiibo Service open source project
|
|
//
|
|
// Copyright (c) 2026 Röck+Cöde VoF. and the Amiibo Service project authors
|
|
// Licensed under Apache license v2.0
|
|
//
|
|
// See LICENSE for license information
|
|
// See CONTRIBUTORS for the list of Amiibo Service project authors
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
// ===----------------------------------------------------------------------===
|
|
|
|
import AmiiboService
|
|
import Foundation
|
|
import Testing
|
|
|
|
@Suite("Amiibo Service [Mock]", .tags(.mock))
|
|
struct AmiiboServiceMockTests {
|
|
|
|
// MARK: Get Amiibos tests
|
|
|
|
@Test("returns empty amiibos when mock provides an empty list")
|
|
func getAmiibosEmpty() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(amiibos: []))
|
|
|
|
// WHEN
|
|
let amiibos = try await service.getAmiibos()
|
|
|
|
// THEN
|
|
#expect(amiibos.isEmpty)
|
|
}
|
|
|
|
@Test("returns amiibos when mock provides a list")
|
|
func getAmiibosList() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(amiibos: Fixtures.amiibos))
|
|
|
|
// WHEN
|
|
let amiibos = try await service.getAmiibos()
|
|
|
|
// THEN
|
|
#expect(amiibos == Fixtures.amiibos)
|
|
#expect(amiibos.first?.identifier == "0100000000040002")
|
|
#expect(amiibos.first?.imageURL != nil)
|
|
}
|
|
|
|
@Test("throws notFound when mock provides no amiibos")
|
|
func getAmiibosNotFound() async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient())
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: AmiiboServiceError.notFound) {
|
|
try await service.getAmiibos()
|
|
}
|
|
}
|
|
|
|
@Test("throws error for amiibos when mock is configured with error", arguments: Errors.all)
|
|
func getAmiibosThrows(error: AmiiboServiceError) async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(error: error))
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: error) {
|
|
try await service.getAmiibos()
|
|
}
|
|
}
|
|
|
|
// MARK: Get Amiibo Series tests
|
|
|
|
@Test("returns empty amiibo series when mock provides an empty list")
|
|
func getAmiiboSeriesEmpty() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(amiiboSeries: []))
|
|
|
|
// WHEN
|
|
let amiiboSeries = try await service.getAmiiboSeries()
|
|
|
|
// THEN
|
|
#expect(amiiboSeries.isEmpty)
|
|
}
|
|
|
|
@Test("returns amiibo series when mock provides a list")
|
|
func getAmiiboSeriesList() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(amiiboSeries: Fixtures.amiiboSeries))
|
|
|
|
// WHEN
|
|
let amiiboSeries = try await service.getAmiiboSeries()
|
|
|
|
// THEN
|
|
#expect(amiiboSeries == Fixtures.amiiboSeries)
|
|
}
|
|
|
|
@Test("throws notFound when mock provides no amiibo series")
|
|
func getAmiiboSeriesNotFound() async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient())
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: AmiiboServiceError.notFound) {
|
|
try await service.getAmiiboSeries()
|
|
}
|
|
}
|
|
|
|
@Test("throws error for amiibo series when mock is configured with error", arguments: Errors.all)
|
|
func getAmiiboSeriesThrows(error: AmiiboServiceError) async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(error: error))
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: error) {
|
|
try await service.getAmiiboSeries()
|
|
}
|
|
}
|
|
|
|
// MARK: Get Amiibo Types tests
|
|
|
|
@Test("returns empty amiibo types when mock provides an empty list")
|
|
func getAmiiboTypesEmpty() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(amiiboTypes: []))
|
|
|
|
// WHEN
|
|
let amiiboTypes = try await service.getAmiiboTypes()
|
|
|
|
// THEN
|
|
#expect(amiiboTypes.isEmpty)
|
|
}
|
|
|
|
@Test("returns amiibo types when mock provides a list")
|
|
func getAmiiboTypesList() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(amiiboTypes: Fixtures.amiiboTypes))
|
|
|
|
// WHEN
|
|
let amiiboTypes = try await service.getAmiiboTypes()
|
|
|
|
// THEN
|
|
#expect(amiiboTypes == Fixtures.amiiboTypes)
|
|
}
|
|
|
|
@Test("throws notFound when mock provides no amiibo types")
|
|
func getAmiiboTypesNotFound() async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient())
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: AmiiboServiceError.notFound) {
|
|
try await service.getAmiiboTypes()
|
|
}
|
|
}
|
|
|
|
@Test("throws error for amiibo types when mock is configured with error", arguments: Errors.all)
|
|
func getAmiiboTypesThrows(error: AmiiboServiceError) async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(error: error))
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: error) {
|
|
try await service.getAmiiboTypes()
|
|
}
|
|
}
|
|
|
|
// MARK: Get Game Characters tests
|
|
|
|
@Test("returns empty game characters when mock provides an empty list")
|
|
func getGameCharactersEmpty() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(gameCharacters: []))
|
|
|
|
// WHEN
|
|
let gameCharacters = try await service.getGameCharacters()
|
|
|
|
// THEN
|
|
#expect(gameCharacters.isEmpty)
|
|
}
|
|
|
|
@Test("returns game characters when mock provides a list")
|
|
func getGameCharactersList() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(gameCharacters: Fixtures.gameCharacters))
|
|
|
|
// WHEN
|
|
let gameCharacters = try await service.getGameCharacters()
|
|
|
|
// THEN
|
|
#expect(gameCharacters == Fixtures.gameCharacters)
|
|
}
|
|
|
|
@Test("throws notFound when mock provides no game characters")
|
|
func getGameCharactersNotFound() async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient())
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: AmiiboServiceError.notFound) {
|
|
try await service.getGameCharacters()
|
|
}
|
|
}
|
|
|
|
@Test("throws error for game characters when mock is configured with error", arguments: Errors.all)
|
|
func getGameCharactersThrows(error: AmiiboServiceError) async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(error: error))
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: error) {
|
|
try await service.getGameCharacters()
|
|
}
|
|
}
|
|
|
|
// MARK: Get Game Series tests
|
|
|
|
@Test("returns empty game series when mock provides an empty list")
|
|
func getGameSeriesEmpty() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(gameSeries: []))
|
|
|
|
// WHEN
|
|
let gameSeries = try await service.getGameSeries()
|
|
|
|
// THEN
|
|
#expect(gameSeries.isEmpty)
|
|
}
|
|
|
|
@Test("returns game series when mock provides a list")
|
|
func getGameSeriesList() async throws {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(gameSeries: Fixtures.gameSeries))
|
|
|
|
// WHEN
|
|
let gameSeries = try await service.getGameSeries()
|
|
|
|
// THEN
|
|
#expect(gameSeries == Fixtures.gameSeries)
|
|
}
|
|
|
|
@Test("throws notFound when mock provides no game series")
|
|
func getGameSeriesNotFound() async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient())
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: AmiiboServiceError.notFound) {
|
|
try await service.getGameSeries()
|
|
}
|
|
}
|
|
|
|
@Test("throws error for game series when mock is configured with error", arguments: Errors.all)
|
|
func getGameSeriesThrows(error: AmiiboServiceError) async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(error: error))
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: error) {
|
|
try await service.getGameSeries()
|
|
}
|
|
}
|
|
|
|
// MARK: Get Last Updated tests
|
|
|
|
@Test("returns date when mock provides a last updated date")
|
|
func getLastUpdated() async throws {
|
|
// GIVEN
|
|
let expectedDate = Date(timeIntervalSince1970: 1_700_000_000)
|
|
let service = AmiiboService(client: AmiiboMockClient(lastUpdated: expectedDate))
|
|
|
|
// WHEN
|
|
let lastUpdated = try await service.getLastUpdated()
|
|
|
|
// THEN
|
|
#expect(lastUpdated == expectedDate)
|
|
}
|
|
|
|
@Test("throws notFound when mock provides no last updated date")
|
|
func getLastUpdatedNotFound() async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient())
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: AmiiboServiceError.notFound) {
|
|
try await service.getLastUpdated()
|
|
}
|
|
}
|
|
|
|
@Test("throws error for last updated when mock is configured with error", arguments: Errors.all)
|
|
func getLastUpdatedThrows(error: AmiiboServiceError) async {
|
|
// GIVEN
|
|
let service = AmiiboService(client: AmiiboMockClient(error: error))
|
|
|
|
// WHEN
|
|
// THEN
|
|
await #expect(throws: error) {
|
|
try await service.getLastUpdated()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - Arguments
|
|
|
|
private enum Errors {
|
|
/// All possible errors that can be thrown by the service.
|
|
static let all: [AmiiboServiceError] = [
|
|
.badRequest,
|
|
.cancelled,
|
|
.decoding,
|
|
.notAvailable,
|
|
.notFound,
|
|
.undocumented(500),
|
|
.unknown("An underlying error description.")
|
|
]
|
|
}
|
|
|
|
private enum Fixtures {
|
|
/// Amiibo items; the first one has release dates and related games with usages.
|
|
static let amiibos: [Amiibo] = [
|
|
.init(
|
|
head: "01000000",
|
|
tail: "00040002",
|
|
name: "Zelda",
|
|
type: "Figure",
|
|
series: "Super Smash Bros.",
|
|
gameCharacter: "Zelda",
|
|
gameSeries: "The Legend of Zelda",
|
|
image: "https://raw.githubusercontent.com/N3evin/AmiiboAPI/master/images/icon_01000000-00040002.png",
|
|
release: .init(
|
|
america: Date(timeIntervalSince1970: 1_416_441_600),
|
|
australia: Date(timeIntervalSince1970: 1_417_564_800),
|
|
europe: Date(timeIntervalSince1970: 1_417_132_800),
|
|
japan: Date(timeIntervalSince1970: 1_417_564_800)
|
|
),
|
|
platform: .init(
|
|
switch: [
|
|
.init(
|
|
identifiers: ["01007EF00011E000"],
|
|
name: "The Legend of Zelda: Breath of the Wild",
|
|
usages: [.init(explanation: "Spawns a random selection of items.", isWriteable: false)]
|
|
)
|
|
],
|
|
wiiU: [
|
|
.init(
|
|
identifiers: ["0005000010145000"],
|
|
name: "Super Smash Bros. for Wii U",
|
|
usages: [.init(explanation: "Unlocks a figure player.", isWriteable: true)]
|
|
)
|
|
]
|
|
)
|
|
),
|
|
.init(
|
|
head: "00000000",
|
|
tail: "00000002",
|
|
name: "Mario",
|
|
type: "Figure",
|
|
series: "Super Smash Bros.",
|
|
gameCharacter: "Mario",
|
|
gameSeries: "Super Mario",
|
|
image: "https://raw.githubusercontent.com/N3evin/AmiiboAPI/master/images/icon_00000000-00000002.png"
|
|
)
|
|
]
|
|
/// Amiibo series.
|
|
static let amiiboSeries: [AmiiboSeries] = [
|
|
.init(key: "0x00", name: "Super Smash Bros."),
|
|
.init(key: "0x01", name: "Super Mario")
|
|
]
|
|
/// Amiibo types.
|
|
static let amiiboTypes: [AmiiboType] = [
|
|
.init(key: "0x00", name: "Figure"),
|
|
.init(key: "0x01", name: "Card")
|
|
]
|
|
/// Game characters.
|
|
static let gameCharacters: [GameCharacter] = [
|
|
.init(key: "0x0000", name: "Mario"),
|
|
.init(key: "0x0100", name: "Zelda")
|
|
]
|
|
/// Game series.
|
|
static let gameSeries: [GameSeries] = [
|
|
.init(key: "0x000", name: "Super Mario"),
|
|
.init(key: "0x010", name: "The Legend of Zelda")
|
|
]
|
|
}
|