From b29815f044d9096f03305c6d7e741ca342c5de4f Mon Sep 17 00:00:00 2001 From: Javier Cicchelli Date: Mon, 9 Sep 2024 00:11:14 +0200 Subject: [PATCH] Written test cases for the AmiiboServiceLiveTests tests in the tests target. --- Sources/Public/Clients/AmiiboMockClient.swift | 12 +- Sources/Public/Services/AmiiboService.swift | 1 - Tests/AmiiboServiceLiveTests.swift | 1135 +++++++++++++++++ Tests/amiibo_apiTests.swift | 7 - 4 files changed, 1141 insertions(+), 14 deletions(-) create mode 100644 Tests/AmiiboServiceLiveTests.swift delete mode 100644 Tests/amiibo_apiTests.swift diff --git a/Sources/Public/Clients/AmiiboMockClient.swift b/Sources/Public/Clients/AmiiboMockClient.swift index aab20ed..bf90c65 100644 --- a/Sources/Public/Clients/AmiiboMockClient.swift +++ b/Sources/Public/Clients/AmiiboMockClient.swift @@ -16,12 +16,12 @@ public struct AmiiboMockClient { // MARK: Properties - private(set) public var amiibos: [Amiibo]? - private(set) public var amiiboSeries: [AmiiboSeries]? - private(set) public var amiiboTypes: [AmiiboType]? - private(set) public var gameCharacters: [GameCharacter]? - private(set) public var gameSeries: [GameSeries]? - private(set) public var lastUpdated: Date? + private let amiibos: [Amiibo]? + private let amiiboSeries: [AmiiboSeries]? + private let amiiboTypes: [AmiiboType]? + private let gameCharacters: [GameCharacter]? + private let gameSeries: [GameSeries]? + private let lastUpdated: Date? // MARK: Initialisers diff --git a/Sources/Public/Services/AmiiboService.swift b/Sources/Public/Services/AmiiboService.swift index 7b6023f..f983a3a 100644 --- a/Sources/Public/Services/AmiiboService.swift +++ b/Sources/Public/Services/AmiiboService.swift @@ -11,7 +11,6 @@ //===----------------------------------------------------------------------=== import Foundation -import OpenAPIRuntime public struct AmiiboService { diff --git a/Tests/AmiiboServiceLiveTests.swift b/Tests/AmiiboServiceLiveTests.swift new file mode 100644 index 0000000..dd3544c --- /dev/null +++ b/Tests/AmiiboServiceLiveTests.swift @@ -0,0 +1,1135 @@ +//===----------------------------------------------------------------------=== +// +// This source file is part of the AmiiboAPI open source project +// +// Copyright (c) 2024 Röck+Cöde VoF. and the AmiiboAPI project authors +// Licensed under the EUPL 1.2 or later. +// +// See LICENSE for license information +// See CONTRIBUTORS for the list of AmiiboAPI project authors +// +//===----------------------------------------------------------------------=== + +import AmiiboAPI +import Foundation +import Testing + +struct AmiiboServiceLiveTests { + + // MARK: Properties + + private let service: AmiiboService + + // MARK: Initialisers + + init() throws { + let client = try AmiiboLiveClient() + + self.service = .init(client) + } + + // MARK: Functions tests + + @Test("Get Amiibo items") + func getAmiibos() async throws { + // GIVEN + // WHEN + let amiibos = try await service.getAmiibos() + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + #expect(amiibos.first?.identifier == "0000000000000002") + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.identifier == "3f000000042e0002") + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by an existing identifier") + func getAmiibos_byExistingIdentifier() async throws { + // GIVEN + let identifier = "0000000000000002" + + // WHEN + let amiibos = try await service.getAmiibos(.init(identifier: identifier)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 1) + #expect(amiibos.first?.identifier == identifier) + #expect(amiibos.first?.platform == nil) + } + + @Test("Get Amiibo items by a non-existing identifier") + func getAmiibos_byNonExistingIdentifier() async throws { + // GIVEN + let identifier = "0000000000000000" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.undocumented(404)) { + try await service.getAmiibos(.init(identifier: identifier)) + } + } + + @Test("Get Amiibo items by an incomplete identifier") + func getAmiibos_byIncompleteIdentifier() async throws { + // GIVEN + let identifier = "0000000" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.undocumented(404)) { + try await service.getAmiibos(.init(identifier: identifier)) + } + } + + @Test("Get Amiibo items by an empty identifier") + func getAmiibos_byEmptyIdentifier() async throws { + // GIVEN + let identifier = "" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiibos(.init(identifier: identifier)) + } + } + + @Test("Get Amiibo items by an existing name") + func getAmiibos_byExistingName() async throws { + // GIVEN + let name = "zelda" + + // WHEN + let amiibos = try await service.getAmiibos(.init(name: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 5) + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.platform == nil) + + let nameFirst = try #require(amiibos.first?.name.lowercased()) + let nameLast = try #require(amiibos.last?.name.lowercased()) + + #expect(nameFirst.contains(name)) + #expect(nameLast.contains(name)) + } + + @Test("Get Amiibo items by a non-existing name") + func getAmiibos_byNonExistingName() async throws { + // GIVEN + let name = "Something" + + // WHEN + let amiibos = try await service.getAmiibos(.init(name: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an incomplete name") + func getAmiibos_byIncompleteName() async throws { + // GIVEN + let name = "zel" + + // WHEN + let amiibos = try await service.getAmiibos(.init(name: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 7) + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.platform == nil) + + let nameFirst = try #require(amiibos.first?.name.lowercased()) + let nameLast = try #require(amiibos.last?.name.lowercased()) + + #expect(nameFirst.contains(name)) + #expect(nameLast.contains(name)) + } + + @Test("Get Amiibo items by an empty name") + func getAmiibos_byEmptyName() async throws { + // GIVEN + let name = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(name: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + } + + @Test("Get Amiibo items by an existing type key") + func getAmiibos_byExistingTypeKey() async throws { + // GIVEN + let key = "0x00" + + // WHEN + let amiibos = try await service.getAmiibos(.init(type: key)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 227) + #expect(amiibos.first?.type == "Figure") + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.type == "Figure") + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by an existing type name") + func getAmiibos_byExistingTypeName() async throws { + // GIVEN + let name = "figure" + + // WHEN + let amiibos = try await service.getAmiibos(.init(type: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 227) + #expect(amiibos.first?.type == "Figure") + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.type == "Figure") + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by a non-existing type key") + func getAmiibos_byNonExistingTypeKey() async throws { + // GIVEN + let key = "0x0f" + + // WHEN + let amiibos = try await service.getAmiibos(.init(type: key)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by a non-existing type name") + func getAmiibos_byNonExistingTypeName() async throws { + // GIVEN + let name = "something" + + // WHEN + let amiibos = try await service.getAmiibos(.init(type: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an incomplete type key") + func getAmiibos_byIncompleteTypeKey() async throws { + // GIVEN + let key = "0x" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiibos(.init(type: key)) + } + } + + @Test("Get Amiibo items by an incomplete type name") + func getAmiibos_byIncompleteTypeName() async throws { + // GIVEN + let name = "fig" + + // WHEN + let amiibos = try await service.getAmiibos(.init(type: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an empty type key") + func getAmiibos_byEmptyTypeKey() async throws { + // GIVEN + let key = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(type: key)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an empty type name") + func getAmiibos_byEmptyTypeName() async throws { + // GIVEN + let name = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(type: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an existing series key") + func getAmiibos_byExistingSeriesKey() async throws { + // GIVEN + let key = "0x00" + + // WHEN + let amiibos = try await service.getAmiibos(.init(series: key)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 96) + #expect(amiibos.first?.series == "Super Smash Bros.") + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.series == "Super Smash Bros.") + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by an existing series name") + func getAmiibos_byExistingSeriesName() async throws { + // GIVEN + let name = "Legend Of Zelda" + + // WHEN + let amiibos = try await service.getAmiibos(.init(series: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 22) + #expect(amiibos.first?.series == name) + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.series == name) + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by a non-existing series key") + func getAmiibos_byNonExistingSeriesKey() async throws { + // GIVEN + let key = "0xf9" + + // WHEN + let amiibos = try await service.getAmiibos(.init(series: key)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by a non-existing series name") + func getAmiibos_byNonExistingSeriesName() async throws { + // GIVEN + let name = "something" + + // WHEN + let amiibos = try await service.getAmiibos(.init(series: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an incomplete series key") + func getAmiibos_byIncompleteSeriesKey() async throws { + // GIVEN + let key = "0x" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiibos(.init(series: key)) + } + } + + @Test("Get Amiibo items by an incomplete series name") + func getAmiibos_byIncompleteSeriesName() async throws { + // GIVEN + let name = "fig" + + // WHEN + let amiibos = try await service.getAmiibos(.init(series: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an empty series key") + func getAmiibos_byEmptySeriesKey() async throws { + // GIVEN + let key = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(series: key)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + } + + @Test("Get Amiibo items by an empty series name") + func getAmiibos_byEmptySeriesName() async throws { + // GIVEN + let name = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(series: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + } + + @Test("Get Amiibo items by an existing game character key") + func getAmiibos_byExistingGameCharacterKey() async throws { + // GIVEN + let key = "0x00" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameCharacter: key)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 11) + #expect(amiibos.first?.gameCharacter == "Mario") + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.gameCharacter == "Mario") + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by an existing game character name") + func getAmiibos_byExistingGameCharacterName() async throws { + // GIVEN + let name = "Zelda" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameCharacter: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 6) + #expect(amiibos.first?.gameCharacter == name) + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.gameCharacter == name) + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by a non-existing game character key") + func getAmiibos_byNonExistingGameCharacterKey() async throws { + // GIVEN + let key = "0xf9" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameCharacter: key)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by a non-existing game character name") + func getAmiibos_byNonExistingGameCharacterName() async throws { + // GIVEN + let name = "something" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameCharacter: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an incomplete game character key") + func getAmiibos_byIncompleteGameCharacterKey() async throws { + // GIVEN + let key = "0x" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiibos(.init(gameCharacter: key)) + } + } + + @Test("Get Amiibo items by an incomplete game character name") + func getAmiibos_byIncompleteGameCharacterName() async throws { + // GIVEN + let name = "fig" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameCharacter: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an empty game character key") + func getAmiibos_byEmptyGameCharacterKey() async throws { + // GIVEN + let key = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameCharacter: key)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + } + + @Test("Get Amiibo items by an empty game character name") + func getAmiibos_byEmptyGameCharacterName() async throws { + // GIVEN + let name = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameCharacter: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + } + + @Test("Get Amiibo items by an existing game series key") + func getAmiibos_byExistingGameSeriesKey() async throws { + // GIVEN + let key = "0x00" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameSeries: key)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 42) + #expect(amiibos.first?.gameSeries == "Super Mario") + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.gameSeries == "Super Mario") + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by an existing game series name") + func getAmiibos_byExistingGameSeriesName() async throws { + // GIVEN + let name = "The Legend of Zelda" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameSeries: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 28) + #expect(amiibos.first?.gameSeries == name) + #expect(amiibos.first?.platform == nil) + #expect(amiibos.last?.gameSeries == name) + #expect(amiibos.last?.platform == nil) + } + + @Test("Get Amiibo items by a non-existing game series key") + func getAmiibos_byNonExistingGameSeriesKey() async throws { + // GIVEN + let key = "0xf9" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameSeries: key)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by a non-existing game series name") + func getAmiibos_byNonExistingGameSeriesName() async throws { + // GIVEN + let name = "something" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameSeries: name)) + + // THEN + #expect(amiibos.isEmpty) + } + + @Test("Get Amiibo items by an incomplete game series key") + func getAmiibos_byIncompleteGameSeriesKey() async throws { + // GIVEN + let key = "0x" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiibos(.init(gameSeries: key)) + } + } + + @Test("Get Amiibo items by an incomplete game series name") + func getAmiibos_byIncompleteGameSeriesName() async throws { + // GIVEN + let name = "Super" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameSeries: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 140) + } + + @Test("Get Amiibo items by an empty game series key") + func getAmiibos_byEmptyGameSeriesKey() async throws { + // GIVEN + let key = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameSeries: key)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + } + + @Test("Get Amiibo items by an empty game series name") + func getAmiibos_byEmptyGameSeriesName() async throws { + // GIVEN + let name = "" + + // WHEN + let amiibos = try await service.getAmiibos(.init(gameSeries: name)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + } + + @Test("Get Amiibo items with games data") + func getAmiibos_withGamesData() async throws { + // GIVEN + // WHEN + let amiibos = try await service.getAmiibos(.init(showGames: true)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + #expect(amiibos.first?.platform != nil) + #expect(amiibos.first?.platform?.switch.isEmpty == false) + #expect(amiibos.first?.platform?.switch.first?.usages == nil) + #expect(amiibos.first?.platform?.threeDS.isEmpty == false) + #expect(amiibos.first?.platform?.threeDS.first?.usages == nil) + #expect(amiibos.first?.platform?.wiiU.isEmpty == false) + #expect(amiibos.first?.platform?.wiiU.first?.usages == nil) + #expect(amiibos.last?.platform != nil) + } + + @Test("Get Amiibo items with games and usages data") + func getAmiibos_withGamesAndUsagesData() async throws { + // GIVEN + // WHEN + let amiibos = try await service.getAmiibos(.init(showUsage: true)) + + // THEN + #expect(!amiibos.isEmpty) + #expect(amiibos.count == 853) + #expect(amiibos.first?.platform != nil) + #expect(amiibos.first?.platform?.switch.isEmpty == false) + #expect(amiibos.first?.platform?.switch.first?.usages?.isEmpty == false) + #expect(amiibos.first?.platform?.threeDS.isEmpty == false) + #expect(amiibos.first?.platform?.threeDS.first?.usages?.isEmpty == false) + #expect(amiibos.first?.platform?.wiiU.isEmpty == false) + #expect(amiibos.first?.platform?.wiiU.first?.usages?.isEmpty == false) + #expect(amiibos.last?.platform != nil) + } + + @Test("Get Amiibo series") + func getAmiiboSeries() async throws { + // GIVEN + // WHEN + let amiiboSeries = try await service.getAmiiboSeries() + + // THEN + #expect(!amiiboSeries.isEmpty) + #expect(amiiboSeries.count == 26) + #expect(amiiboSeries.first?.key == "0x00") + #expect(amiiboSeries.last?.key == "0xff") + } + + @Test("Get Amiibo series by an existing key") + func getAmiiboSeries_byExistingKey() async throws { + // GIVEN + let key = "0x01" + + // WHEN + let amiiboSeries = try await service.getAmiiboSeries(.init(key: key)) + + // THEN + #expect(!amiiboSeries.isEmpty) + #expect(amiiboSeries.count == 1) + #expect(amiiboSeries.first?.key == key) + } + + @Test("Get Amiibo series by a non-existing key") + func getAmiiboSeries_byNonExistingKey() async throws { + // GIVEN + let key = "0xf9" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getAmiiboSeries(.init(key: key)) + } + } + + @Test("Get Amiibo series by an incomplete key") + func getAmiiboSeries_byIncompleteKey() async throws { + // GIVEN + let key = "0x" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiiboSeries(.init(key: key)) + } + } + + @Test("Get Amiibo series by an empty key") + func getAmiiboSeries_byEmptyKey() async throws { + // GIVEN + let key = "" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiiboSeries(.init(key: key)) + } + } + + @Test("Get Amiibo series by an existing name") + func getAmiiboSeries_byExistingName() async throws { + // GIVEN + let name = "Legend Of Zelda" + + // WHEN + let amiiboSeries = try await service.getAmiiboSeries(.init(name: name)) + + // THEN + #expect(!amiiboSeries.isEmpty) + #expect(amiiboSeries.count == 1) + #expect(amiiboSeries.first?.name == name) + } + + @Test("Get Amiibo series by a non-existing name") + func getAmiiboSeries_byNonExistingName() async throws { + // GIVEN + let name = "Something" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getAmiiboSeries(.init(name: name)) + } + } + + @Test("Get Amiibo series by an incomplete name") + func getAmiiboSeries_byIncompleteName() async throws { + // GIVEN + let name = "Zelda" + + // WHEN + let amiiboSeries = try await service.getAmiiboSeries(.init(name: name)) + + // THEN + #expect(!amiiboSeries.isEmpty) + #expect(amiiboSeries.count == 1) + + let amiiboSeriesName = try #require(amiiboSeries.first) + + #expect(amiiboSeriesName.name.contains(name)) + } + + @Test("Get Amiibo series by an empty name") + func getAmiiboSeries_byEmptyName() async throws { + // GIVEN + let name = "" + + // WHEN + let amiiboSeries = try await service.getAmiiboSeries(.init(name: name)) + + // THEN + #expect(!amiiboSeries.isEmpty) + #expect(amiiboSeries.count == 26) + #expect(amiiboSeries.first?.key == "0x00") + #expect(amiiboSeries.last?.key == "0xff") + } + + @Test("Get Amiibo types") + func getAmiiboTypes() async throws { + // GIVEN + // WHEN + let amiiboTypes = try await service.getAmiiboTypes() + + // THEN + #expect(!amiiboTypes.isEmpty) + #expect(amiiboTypes.count == 4) + #expect(amiiboTypes.first?.key == "0x00") + #expect(amiiboTypes.last?.key == "0x03") + } + + @Test("Get Amiibo types by an existing key") + func getAmiiboTypes_byExistingKey() async throws { + // GIVEN + let key = "0x01" + + // WHEN + let amiiboTypes = try await service.getAmiiboTypes(.init(key: key)) + + // THEN + #expect(!amiiboTypes.isEmpty) + #expect(amiiboTypes.count == 1) + #expect(amiiboTypes.first?.key == key) + } + + @Test("Get Amiibo types by a non-existing key") + func getAmiiboTypes_byNonExistingKey() async throws { + // GIVEN + let key = "0x09" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getAmiiboTypes(.init(key: key)) + } + } + + @Test("Get Amiibo types by an incomplete key") + func getAmiiboTypes_byIncompleteKey() async throws { + // GIVEN + let key = "0x" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiiboTypes(.init(key: key)) + } + } + + @Test("Get Amiibo types by an empty key") + func getAmiiboTypes_byEmptyKey() async throws { + // GIVEN + let key = "" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getAmiiboTypes(.init(key: key)) + } + } + + @Test("Get Amiibo types by an existing name") + func getAmiiboTypes_byExistingName() async throws { + // GIVEN + let name = "Card" + + // WHEN + let amiiboTypes = try await service.getAmiiboTypes(.init(name: name)) + + // THEN + #expect(!amiiboTypes.isEmpty) + #expect(amiiboTypes.count == 1) + #expect(amiiboTypes.first?.name == name) + } + + @Test("Get Amiibo types by a non-existing name") + func getAmiiboTypes_byNonExistingName() async throws { + // GIVEN + let name = "Something" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getAmiiboTypes(.init(name: name)) + } + } + + @Test("Get Amiibo types by an incomplete name") + func getAmiiboTypes_byIncompleteName() async throws { + // GIVEN + let name = "Ca" + + // WHEN + let amiiboTypes = try await service.getAmiiboTypes(.init(name: name)) + + // THEN + #expect(!amiiboTypes.isEmpty) + #expect(amiiboTypes.count == 1) + + let amiiboTypeName = try #require(amiiboTypes.first) + + #expect(amiiboTypeName.name.contains(name)) + } + + @Test("Get Amiibo types by an empty name") + func getAmiiboTypes_byEmptyName() async throws { + // GIVEN + let name = "" + + // WHEN + let amiiboTypes = try await service.getAmiiboTypes(.init(name: name)) + + // THEN + #expect(!amiiboTypes.isEmpty) + #expect(amiiboTypes.count == 4) + #expect(amiiboTypes.first?.key == "0x00") + #expect(amiiboTypes.last?.key == "0x03") + } + + @Test("Get game characters") + func getGameCharacters() async throws { + // GIVEN + // WHEN + let gameCharacters = try await service.getGameCharacters() + + // THEN + #expect(!gameCharacters.isEmpty) + #expect(gameCharacters.count == 644) + #expect(gameCharacters.first?.key == "0x0000") + #expect(gameCharacters.last?.key == "0x3f00") + } + + @Test("Get game characters by an existing key") + func getGameCharacters_byExistingKey() async throws { + // GIVEN + let key = "0x0001" + + // WHEN + let gameCharacters = try await service.getGameCharacters(.init(key: key)) + + // THEN + #expect(!gameCharacters.isEmpty) + #expect(gameCharacters.count == 1) + #expect(gameCharacters.first?.key == key) + } + + @Test("Get game characters by a non-existing key") + func getGameCharacters_byNonExistingKey() async throws { + // GIVEN + let key = "0xffff" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getGameCharacters(.init(key: key)) + } + } + + @Test("Get game characters by an incomplete key") + func getGameCharacters_byIncompleteKey() async throws { + // GIVEN + let key = "0x" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getGameCharacters(.init(key: key)) + } + } + + @Test("Get game characters by an empty key") + func getGameCharacters_byEmptyKey() async throws { + // GIVEN + let key = "" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getGameCharacters(.init(key: key)) + } + } + + @Test("Get game characters by an existing name") + func getGameCharacters_byExistingName() async throws { + // GIVEN + let name = "Zelda" + + // WHEN + let gameCharacters = try await service.getGameCharacters(.init(name: name)) + + // THEN + #expect(!gameCharacters.isEmpty) + #expect(gameCharacters.count == 1) + #expect(gameCharacters.first?.name == name) + } + + @Test("Get game characters by a non-existing name") + func getGameCharacters_byNonExistingName() async throws { + // GIVEN + let name = "Something" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getGameCharacters(.init(name: name)) + } + } + + @Test("Get game characters by an incomplete name") + func getGameCharacters_byIncompleteName() async throws { + // GIVEN + let name = "Zeld" + + // WHEN + let gameCharacters = try await service.getGameCharacters(.init(name: name)) + + // THEN + #expect(!gameCharacters.isEmpty) + #expect(gameCharacters.count == 1) + + let gameCharactersName = try #require(gameCharacters.first) + + #expect(gameCharactersName.name.contains(name)) + } + + @Test("Get game characters by an empty name") + func getGameCharacters_byEmptyName() async throws { + // GIVEN + let name = "" + + // WHEN + let gameCharacters = try await service.getGameCharacters(.init(name: name)) + + // THEN + #expect(!gameCharacters.isEmpty) + #expect(gameCharacters.count == 644) + #expect(gameCharacters.first?.key == "0x0000") + #expect(gameCharacters.last?.key == "0x3f00") + } + + @Test("Get game series") + func getGameSeries() async throws { + // GIVEN + // WHEN + let gameSeries = try await service.getGameSeries() + + // THEN + #expect(!gameSeries.isEmpty) + #expect(gameSeries.count == 116) + #expect(gameSeries.first?.key == "0x000") + #expect(gameSeries.last?.key == "0x3f0") + } + + @Test("Get game series by an existing key") + func getGameSeries_byExistingKey() async throws { + // GIVEN + let key = "0x001" + + // WHEN + let gameSeries = try await service.getGameSeries(.init(key: key)) + + // THEN + #expect(!gameSeries.isEmpty) + #expect(gameSeries.count == 1) + #expect(gameSeries.first?.key == key) + } + + @Test("Get game series by a non-existing key") + func getGameSeries_byNonExistingKey() async throws { + // GIVEN + let key = "0xffff" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getGameSeries(.init(key: key)) + } + } + + @Test("Get game series by an incomplete key") + func getGameSeries_byIncompleteKey() async throws { + // GIVEN + let key = "0x" + + // WHEN & THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getGameSeries(.init(key: key)) + } + } + + @Test("Get game series by an empty key") + func getGameSeries_byEmptyKey() async throws { + // GIVEN + let key = "" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.badRequest) { + try await service.getGameSeries(.init(key: key)) + } + } + + @Test("Get game series by an existing name") + func getGameSeries_byExistingName() async throws { + // GIVEN + let name = "Pikmin" + + // WHEN + let gameSeries = try await service.getGameSeries(.init(name: name)) + + // THEN + #expect(!gameSeries.isEmpty) + #expect(gameSeries.count == 1) + #expect(gameSeries.first?.name == name) + } + + @Test("Get game series by a non-existing name") + func getGameSeries_byNonExistingName() async throws { + // GIVEN + let name = "Something" + + // WHEN + // THEN + await #expect(throws: AmiiboServiceError.notFound) { + try await service.getGameSeries(.init(name: name)) + } + } + + @Test("Get game series by an incomplete name") + func getGameSeries_byIncompleteName() async throws { + // GIVEN + let name = "Pik" + + // WHEN + let gameSeries = try await service.getGameSeries(.init(name: name)) + + // THEN + #expect(!gameSeries.isEmpty) + #expect(gameSeries.count == 1) + + let gameSeriesName = try #require(gameSeries.first) + + #expect(gameSeriesName.name.contains(name)) + } + + @Test("Get game series by an empty name") + func getGameSeries_byEmptyName() async throws { + // GIVEN + let name = "" + + // WHEN + let gameSeries = try await service.getGameSeries(.init(name: name)) + + // THEN + #expect(!gameSeries.isEmpty) + #expect(gameSeries.count == 116) + #expect(gameSeries.first?.key == "0x000") + #expect(gameSeries.last?.key == "0x3f0") + } + + @Test("Get the last updated timestamp") + func getLastUpdated() async throws { + // GIVEN + // WHEN + let dateLastUpdated = try await service.getLastUpdated() + + // THEN + let dateComponents = Calendar.current.dateComponents( + [.year, .month, .day], + from: dateLastUpdated + ) + + #expect(dateComponents.year == 2024) + #expect(dateComponents.month == 9) + #expect(dateComponents.day == 6) + } + +} diff --git a/Tests/amiibo_apiTests.swift b/Tests/amiibo_apiTests.swift deleted file mode 100644 index 26a09ea..0000000 --- a/Tests/amiibo_apiTests.swift +++ /dev/null @@ -1,7 +0,0 @@ -import Testing - -@testable import AmiiboAPI - -@Test func example() async throws { - // Write your test here and use APIs like `#expect(...)` to check expected conditions. -}