From 7a0c88e661cad2d3ea8d83fa3c537a923fe288fb Mon Sep 17 00:00:00 2001 From: flx-sta <50131232+flx-sta@users.noreply.github.com> Date: Mon, 4 Nov 2024 12:57:21 -0800 Subject: [PATCH] [Refactor] Pokerogue API client (#4583) * start migrating Utils.apiFetch to api class * move dailyranking to api * use api in title-ui-handler * remove: Utils.apiFetch * migrate `updateSystemSavedata` to api * migrate clear session savedata to api * migrate updateAllSavedata to api * migrate `updateSessionSavedata` to api * rename `api` to `pokerogue-api` * migrate unlink discord to pokerogue-api * migrate unlink google to pokerogue-api * update pokerogue-api login * migrate register account to pokerogue-api * remove Utils.apiPost * reset overrides.ts * chore: cleanup * fix env.development * fix circular dependencies with api * fix gamedata verify missing await * fix daily api calls in daily-run-scorebard * fix discord-link request body being empty there was a double `toUrlSearchParams()` call involved * add pokerogue-api test coverge * add test-utils `getApiBaseUrl()` method * add pokerogue-admin-api test coverage * add pokerogue-account-api test coverage * add pokerogue-daily-api test coverage * add pokerogue-savedata-api test coverage * fix some test describes * add pokerogue-session-savedata-api test coverage * add pokerogue-system-savedata-api test coverage * fix tests * fix tryExportData thanks @MokaStitcher * chore: fix menu-ui-handlers.ts * fix admin-ui-handler (types) * extend test-coverage for admin-api * remove outdated code * skip some clowning-around-encounter tests if events are active this is not a permanent solution * Update src/system/game-data.ts Co-authored-by: PigeonBar <56974298+PigeonBar@users.noreply.github.com> * Revert "skip some clowning-around-encounter tests if events are active" This reverts commit a97dafe8b2479e9b2ddd49d4dc9710814d7c7b67. * mark `localServerUrl` and `apiUrl` as deprecated in `utils.ts` --------- Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com> Co-authored-by: PigeonBar <56974298+PigeonBar@users.noreply.github.com> --- global.d.ts | 2 +- src/@types/PokerogueAccountApi.ts | 17 ++ src/@types/PokerogueAdminApi.ts | 31 +++ src/@types/PokerogueApi.ts | 4 + src/@types/PokerogueDailyApi.ts | 10 + src/@types/PokerogueSavedataApi.ts | 8 + src/@types/PokerogueSessionSavedataApi.ts | 39 +++ src/@types/PokerogueSystemSavedataApi.ts | 20 ++ src/@types/UserInfo.ts | 7 + src/@types/pokerogue-api.ts | 9 - src/account.ts | 26 +- src/constants.ts | 6 + src/data/daily-run.ts | 12 +- src/phases/game-over-phase.ts | 8 +- src/phases/title-phase.ts | 2 +- src/plugins/api/api-base.ts | 91 +++++++ src/plugins/api/pokerogue-account-api.ts | 101 ++++++++ src/plugins/api/pokerogue-admin-api.ts | 140 +++++++++++ src/plugins/api/pokerogue-api.ts | 83 +++++++ src/plugins/api/pokerogue-daily-api.ts | 57 +++++ src/plugins/api/pokerogue-savedata-api.ts | 41 ++++ .../api/pokerogue-session-savedata-api.ts | 115 +++++++++ .../api/pokerogue-system-savedata-api.ts | 77 ++++++ src/system/game-data.ts | 111 ++++----- src/test/account.test.ts | 33 ++- src/test/daily_mode.test.ts | 15 +- src/test/misc.test.ts | 26 +- .../plugins/api/pokerogue-account-api.test.ts | 157 ++++++++++++ .../plugins/api/pokerogue-admin-api.test.ts | 232 ++++++++++++++++++ src/test/plugins/api/pokerogue-api.test.ts | 97 ++++++++ .../plugins/api/pokerogue-daily-api.test.ts | 89 +++++++ .../api/pokerogue-savedata-api.test.ts | 46 ++++ .../pokerogue-session-savedata-api.test.ts | 199 +++++++++++++++ .../api/pokerogue-system-savedata-api.test.ts | 122 +++++++++ src/test/reload.test.ts | 20 +- src/test/system/game_data.test.ts | 26 +- src/test/utils/gameWrapper.ts | 2 +- src/test/utils/testUtils.ts | 8 + src/test/vitest.setup.ts | 11 +- src/ui/admin-ui-handler.ts | 75 ++++-- src/ui/daily-run-scoreboard.ts | 16 +- src/ui/login-form-ui-handler.ts | 26 +- src/ui/menu-ui-handler.ts | 17 +- src/ui/registration-form-ui-handler.ts | 27 +- src/ui/title-ui-handler.ts | 12 +- src/utils.ts | 52 +--- 46 files changed, 2036 insertions(+), 289 deletions(-) create mode 100644 src/@types/PokerogueAccountApi.ts create mode 100644 src/@types/PokerogueAdminApi.ts create mode 100644 src/@types/PokerogueApi.ts create mode 100644 src/@types/PokerogueDailyApi.ts create mode 100644 src/@types/PokerogueSavedataApi.ts create mode 100644 src/@types/PokerogueSessionSavedataApi.ts create mode 100644 src/@types/PokerogueSystemSavedataApi.ts create mode 100644 src/@types/UserInfo.ts delete mode 100644 src/@types/pokerogue-api.ts create mode 100644 src/plugins/api/api-base.ts create mode 100644 src/plugins/api/pokerogue-account-api.ts create mode 100644 src/plugins/api/pokerogue-admin-api.ts create mode 100644 src/plugins/api/pokerogue-api.ts create mode 100644 src/plugins/api/pokerogue-daily-api.ts create mode 100644 src/plugins/api/pokerogue-savedata-api.ts create mode 100644 src/plugins/api/pokerogue-session-savedata-api.ts create mode 100644 src/plugins/api/pokerogue-system-savedata-api.ts create mode 100644 src/test/plugins/api/pokerogue-account-api.test.ts create mode 100644 src/test/plugins/api/pokerogue-admin-api.test.ts create mode 100644 src/test/plugins/api/pokerogue-api.test.ts create mode 100644 src/test/plugins/api/pokerogue-daily-api.test.ts create mode 100644 src/test/plugins/api/pokerogue-savedata-api.test.ts create mode 100644 src/test/plugins/api/pokerogue-session-savedata-api.test.ts create mode 100644 src/test/plugins/api/pokerogue-system-savedata-api.test.ts diff --git a/global.d.ts b/global.d.ts index f4dfa7d4cb2..c896a4983e4 100644 --- a/global.d.ts +++ b/global.d.ts @@ -10,5 +10,5 @@ declare global { * * To set up your own server in a test see `game_data.test.ts` */ - var i18nServer: SetupServerApi; + var server: SetupServerApi; } diff --git a/src/@types/PokerogueAccountApi.ts b/src/@types/PokerogueAccountApi.ts new file mode 100644 index 00000000000..68d0a5e7730 --- /dev/null +++ b/src/@types/PokerogueAccountApi.ts @@ -0,0 +1,17 @@ +import type { UserInfo } from "#app/@types/UserInfo"; + +export interface AccountInfoResponse extends UserInfo {} + +export interface AccountLoginRequest { + username: string; + password: string; +} + +export interface AccountLoginResponse { + token: string; +} + +export interface AccountRegisterRequest { + username: string; + password: string; +} diff --git a/src/@types/PokerogueAdminApi.ts b/src/@types/PokerogueAdminApi.ts new file mode 100644 index 00000000000..2ee25b560d9 --- /dev/null +++ b/src/@types/PokerogueAdminApi.ts @@ -0,0 +1,31 @@ +export interface LinkAccountToDiscordIdRequest { + username: string; + discordId: string; +} + +export interface UnlinkAccountFromDiscordIdRequest { + username: string; + discordId: string; +} + +export interface LinkAccountToGoogledIdRequest { + username: string; + googleId: string; +} + +export interface UnlinkAccountFromGoogledIdRequest { + username: string; + googleId: string; +} + +export interface SearchAccountRequest { + username: string; +} + +export interface SearchAccountResponse { + username: string; + discordId: string; + googleId: string; + lastLoggedIn: string; + registered: string; +} diff --git a/src/@types/PokerogueApi.ts b/src/@types/PokerogueApi.ts new file mode 100644 index 00000000000..79755b23a54 --- /dev/null +++ b/src/@types/PokerogueApi.ts @@ -0,0 +1,4 @@ +export interface TitleStatsResponse { + playerCount: number; + battleCount: number; +} diff --git a/src/@types/PokerogueDailyApi.ts b/src/@types/PokerogueDailyApi.ts new file mode 100644 index 00000000000..3f3d8eb61ca --- /dev/null +++ b/src/@types/PokerogueDailyApi.ts @@ -0,0 +1,10 @@ +import type { ScoreboardCategory } from "#app/ui/daily-run-scoreboard"; + +export interface GetDailyRankingsRequest { + category: ScoreboardCategory; + page?: number; +} + +export interface GetDailyRankingsPageCountRequest { + category: ScoreboardCategory; +} diff --git a/src/@types/PokerogueSavedataApi.ts b/src/@types/PokerogueSavedataApi.ts new file mode 100644 index 00000000000..a313cd708c7 --- /dev/null +++ b/src/@types/PokerogueSavedataApi.ts @@ -0,0 +1,8 @@ +import type { SessionSaveData, SystemSaveData } from "#app/system/game-data"; + +export interface UpdateAllSavedataRequest { + system: SystemSaveData; + session: SessionSaveData; + sessionSlotId: number; + clientSessionId: string; +} diff --git a/src/@types/PokerogueSessionSavedataApi.ts b/src/@types/PokerogueSessionSavedataApi.ts new file mode 100644 index 00000000000..5fcd8575b15 --- /dev/null +++ b/src/@types/PokerogueSessionSavedataApi.ts @@ -0,0 +1,39 @@ +export class UpdateSessionSavedataRequest { + slot: number; + trainerId: number; + secretId: number; + clientSessionId: string; +} + +/** This is **NOT** similar to {@linkcode ClearSessionSavedataRequest} */ +export interface NewClearSessionSavedataRequest { + slot: number; + clientSessionId: string; +} + +export interface GetSessionSavedataRequest { + slot: number; + clientSessionId: string; +} + +export interface DeleteSessionSavedataRequest { + slot: number; + clientSessionId: string; +} + +/** This is **NOT** similar to {@linkcode NewClearSessionSavedataRequest} */ +export interface ClearSessionSavedataRequest { + slot: number; + trainerId: number; + clientSessionId: string; +} + +/** + * Pokerogue API response for path: `/savedata/session/clear` + */ +export interface ClearSessionSavedataResponse { + /** Contains the error message if any occured */ + error?: string; + /** Is `true` if the request was successfully processed */ + success?: boolean; +} diff --git a/src/@types/PokerogueSystemSavedataApi.ts b/src/@types/PokerogueSystemSavedataApi.ts new file mode 100644 index 00000000000..8ce160a5ec2 --- /dev/null +++ b/src/@types/PokerogueSystemSavedataApi.ts @@ -0,0 +1,20 @@ +import type { SystemSaveData } from "#app/system/game-data"; + +export interface GetSystemSavedataRequest { + clientSessionId: string; +} + +export class UpdateSystemSavedataRequest { + clientSessionId: string; + trainerId?: number; + secretId?: number; +} + +export interface VerifySystemSavedataRequest { + clientSessionId: string; +} + +export interface VerifySystemSavedataResponse { + valid: boolean; + systemData: SystemSaveData; +} diff --git a/src/@types/UserInfo.ts b/src/@types/UserInfo.ts new file mode 100644 index 00000000000..c8a0c6ecb26 --- /dev/null +++ b/src/@types/UserInfo.ts @@ -0,0 +1,7 @@ +export interface UserInfo { + username: string; + lastSessionSlot: number; + discordId: string; + googleId: string; + hasAdminRole: boolean; +} diff --git a/src/@types/pokerogue-api.ts b/src/@types/pokerogue-api.ts deleted file mode 100644 index 892869968bb..00000000000 --- a/src/@types/pokerogue-api.ts +++ /dev/null @@ -1,9 +0,0 @@ -/** - * Pokerogue API response for path: `/savedata/session/clear` - */ -export interface PokerogueApiClearSessionData { - /** Contains the error message if any occured */ - error?: string; - /** Is `true` if the request was successfully processed */ - success?: boolean; -} diff --git a/src/account.ts b/src/account.ts index 692ff2b0d81..316645b38ff 100644 --- a/src/account.ts +++ b/src/account.ts @@ -1,14 +1,8 @@ +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; +import type { UserInfo } from "#app/@types/UserInfo"; import { bypassLogin } from "./battle-scene"; import * as Utils from "./utils"; -export interface UserInfo { - username: string; - lastSessionSlot: integer; - discordId: string; - googleId: string; - hasAdminRole: boolean; -} - export let loggedInUser: UserInfo | null = null; // This is a random string that is used to identify the client session - unique per session (tab or window) so that the game will only save on the one that the server is expecting export const clientSessionId = Utils.randomString(32); @@ -43,18 +37,14 @@ export function updateUserInfo(): Promise<[boolean, integer]> { }); return resolve([ true, 200 ]); } - Utils.apiFetch("account/info", true).then(response => { - if (!response.ok) { - resolve([ false, response.status ]); + pokerogueApi.account.getInfo().then(([ accountInfo, status ]) => { + if (!accountInfo) { + resolve([ false, status ]); return; + } else { + loggedInUser = accountInfo; + resolve([ true, 200 ]); } - return response.json(); - }).then(jsonResponse => { - loggedInUser = jsonResponse; - resolve([ true, 200 ]); - }).catch(err => { - console.error(err); - resolve([ false, 500 ]); }); }); } diff --git a/src/constants.ts b/src/constants.ts index 0b1261ad814..63f00b9f33f 100644 --- a/src/constants.ts +++ b/src/constants.ts @@ -3,3 +3,9 @@ export const PLAYER_PARTY_MAX_SIZE: number = 6; /** Whether to use seasonal splash messages in general */ export const USE_SEASONAL_SPLASH_MESSAGES: boolean = false; + +/** Name of the session ID cookie */ +export const SESSION_ID_COOKIE_NAME: string = "pokerogue_sessionId"; + +/** Max value for an integer attribute in {@linkcode SystemSaveData} */ +export const MAX_INT_ATTR_VALUE = 0x80000000; diff --git a/src/data/daily-run.ts b/src/data/daily-run.ts index 0decab63f4f..506ea0471c6 100644 --- a/src/data/daily-run.ts +++ b/src/data/daily-run.ts @@ -6,6 +6,7 @@ import { Starter } from "#app/ui/starter-select-ui-handler"; import * as Utils from "#app/utils"; import PokemonSpecies, { PokemonSpeciesForm, getPokemonSpecies, getPokemonSpeciesForm } from "#app/data/pokemon-species"; import { speciesStarterCosts } from "#app/data/balance/starters"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; export interface DailyRunConfig { seed: integer; @@ -14,14 +15,9 @@ export interface DailyRunConfig { export function fetchDailyRunSeed(): Promise { return new Promise((resolve, reject) => { - Utils.apiFetch("daily/seed").then(response => { - if (!response.ok) { - resolve(null); - return; - } - return response.text(); - }).then(seed => resolve(seed ?? null)) - .catch(err => reject(err)); + pokerogueApi.daily.getSeed().then(dailySeed => { + resolve(dailySeed); + }); }); } diff --git a/src/phases/game-over-phase.ts b/src/phases/game-over-phase.ts index 1302d8fc652..84fad257897 100644 --- a/src/phases/game-over-phase.ts +++ b/src/phases/game-over-phase.ts @@ -23,6 +23,7 @@ import * as Utils from "#app/utils"; import { PlayerGender } from "#enums/player-gender"; import { TrainerType } from "#enums/trainer-type"; import i18next from "i18next"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; export class GameOverPhase extends BattlePhase { private victory: boolean; @@ -176,10 +177,9 @@ export class GameOverPhase extends BattlePhase { If Online, execute apiFetch as intended If Offline, execute offlineNewClear(), a localStorage implementation of newClear daily run checks */ if (this.victory) { - if (!Utils.isLocal) { - Utils.apiFetch(`savedata/session/newclear?slot=${this.scene.sessionSlotId}&clientSessionId=${clientSessionId}`, true) - .then(response => response.json()) - .then(newClear => doGameOver(newClear)); + if (!Utils.isLocal || Utils.isLocalServerConnected) { + pokerogueApi.savedata.session.newclear({ slot: this.scene.sessionSlotId, clientSessionId }) + .then((success) => doGameOver(!!success)); } else { this.scene.gameData.offlineNewClear(this.scene).then(result => { doGameOver(result); diff --git a/src/phases/title-phase.ts b/src/phases/title-phase.ts index 8338d39b81f..88793617776 100644 --- a/src/phases/title-phase.ts +++ b/src/phases/title-phase.ts @@ -243,7 +243,7 @@ export class TitlePhase extends Phase { }; // If Online, calls seed fetch from db to generate daily run. If Offline, generates a daily run based on current date. - if (!Utils.isLocal) { + if (!Utils.isLocal || Utils.isLocalServerConnected) { fetchDailyRunSeed().then(seed => { if (seed) { generateDaily(seed); diff --git a/src/plugins/api/api-base.ts b/src/plugins/api/api-base.ts new file mode 100644 index 00000000000..0740de4e675 --- /dev/null +++ b/src/plugins/api/api-base.ts @@ -0,0 +1,91 @@ +import { SESSION_ID_COOKIE_NAME } from "#app/constants"; +import { getCookie } from "#app/utils"; + +type DataType = "json" | "form-urlencoded"; + +export abstract class ApiBase { + //#region Fields + + public readonly ERR_GENERIC: string = "There was an error"; + + protected readonly base: string; + + //#region Public + + constructor(base: string) { + this.base = base; + } + + //#region Protected + + /** + * Send a GET request. + * @param path The path to send the request to. + */ + protected async doGet(path: string) { + return this.doFetch(path, { method: "GET" }); + } + + /** + * Send a POST request. + * @param path THe path to send the request to. + * @param bodyData The body-data to send. + * @param dataType The data-type of the {@linkcode bodyData}. + */ + protected async doPost(path: string, bodyData?: D, dataType: DataType = "json") { + let body: string | undefined = undefined; + const headers: HeadersInit = {}; + + if (bodyData) { + if (dataType === "json") { + body = typeof bodyData === "string" ? bodyData : JSON.stringify(bodyData); + headers["Content-Type"] = "application/json"; + } else if (dataType === "form-urlencoded") { + if (bodyData instanceof Object) { + body = this.toUrlSearchParams(bodyData).toString(); + } else { + console.warn("Could not add body data to form-urlencoded!", bodyData); + } + headers["Content-Type"] = "application/x-www-form-urlencoded"; + } else { + console.warn(`Unsupported data type: ${dataType}`); + body = String(bodyData); + headers["Content-Type"] = "text/plain"; + } + } + + return await this.doFetch(path, { method: "POST", body, headers }); + } + + /** + * A generic request helper. + * @param path The path to send the request to. + * @param config The request {@linkcode RequestInit | Configuration}. + */ + protected async doFetch(path: string, config: RequestInit): Promise { + config.headers = { + ...config.headers, + Authorization: getCookie(SESSION_ID_COOKIE_NAME), + "Content-Type": config.headers?.["Content-Type"] ?? "application/json", + }; + + console.log(`Sending ${config.method ?? "GET"} request to: `, this.base + path, config); + + return await fetch(this.base + path, config); + } + + /** + * Helper to transform data to {@linkcode URLSearchParams} + * Any key with a value of `undefined` will be ignored. + * Any key with a value of `null` will be included. + * @param data the data to transform to {@linkcode URLSearchParams} + * @returns a {@linkcode URLSearchParams} representaton of {@linkcode data} + */ + protected toUrlSearchParams>(data: D) { + const arr = Object.entries(data) + .map(([ key, value ]) => (value !== undefined ? [ key, String(value) ] : [ key, "" ])) + .filter(([ , value ]) => value !== ""); + + return new URLSearchParams(arr); + } +} diff --git a/src/plugins/api/pokerogue-account-api.ts b/src/plugins/api/pokerogue-account-api.ts new file mode 100644 index 00000000000..66ab8d67520 --- /dev/null +++ b/src/plugins/api/pokerogue-account-api.ts @@ -0,0 +1,101 @@ +import type { + AccountInfoResponse, + AccountLoginRequest, + AccountLoginResponse, + AccountRegisterRequest, +} from "#app/@types/PokerogueAccountApi"; +import { SESSION_ID_COOKIE_NAME } from "#app/constants"; +import { ApiBase } from "#app/plugins/api/api-base"; +import { removeCookie, setCookie } from "#app/utils"; + +/** + * A wrapper for PokéRogue account API requests. + */ +export class PokerogueAccountApi extends ApiBase { + //#region Public + + /** + * Request the {@linkcode AccountInfoResponse | UserInfo} of the logged in user. + * The user is identified by the {@linkcode SESSION_ID_COOKIE_NAME | session cookie}. + */ + public async getInfo(): Promise<[data: AccountInfoResponse | null, status: number]> { + try { + const response = await this.doGet("/account/info"); + + if (response.ok) { + const resData = (await response.json()) as AccountInfoResponse; + return [ resData, response.status ]; + } else { + console.warn("Could not get account info!", response.status, response.statusText); + return [ null, response.status ]; + } + } catch (err) { + console.warn("Could not get account info!", err); + return [ null, 500 ]; + } + } + + /** + * Register a new account. + * @param registerData The {@linkcode AccountRegisterRequest} to send + * @returns An error message if something went wrong + */ + public async register(registerData: AccountRegisterRequest) { + try { + const response = await this.doPost("/account/register", registerData, "form-urlencoded"); + + if (response.ok) { + return null; + } else { + return response.text(); + } + } catch (err) { + console.warn("Register failed!", err); + } + + return "Unknown error!"; + } + + /** + * Send a login request. + * Sets the session cookie on success. + * @param loginData The {@linkcode AccountLoginRequest} to send + * @returns An error message if something went wrong + */ + public async login(loginData: AccountLoginRequest) { + try { + const response = await this.doPost("/account/login", loginData, "form-urlencoded"); + + if (response.ok) { + const loginResponse = (await response.json()) as AccountLoginResponse; + setCookie(SESSION_ID_COOKIE_NAME, loginResponse.token); + return null; + } else { + console.warn("Login failed!", response.status, response.statusText); + return response.text(); + } + } catch (err) { + console.warn("Login failed!", err); + } + + return "Unknown error!"; + } + + /** + * Send a logout request. + * **Always** (no matter if failed or not) removes the session cookie. + */ + public async logout() { + try { + const response = await this.doGet("/account/logout"); + + if (!response.ok) { + throw new Error(`${response.status}: ${response.statusText}`); + } + } catch (err) { + console.warn("Log out failed!", err); + } + + removeCookie(SESSION_ID_COOKIE_NAME); // we are always clearing the cookie. + } +} diff --git a/src/plugins/api/pokerogue-admin-api.ts b/src/plugins/api/pokerogue-admin-api.ts new file mode 100644 index 00000000000..eeba5319adc --- /dev/null +++ b/src/plugins/api/pokerogue-admin-api.ts @@ -0,0 +1,140 @@ +import type { + LinkAccountToDiscordIdRequest, + LinkAccountToGoogledIdRequest, + SearchAccountRequest, + SearchAccountResponse, + UnlinkAccountFromDiscordIdRequest, + UnlinkAccountFromGoogledIdRequest, +} from "#app/@types/PokerogueAdminApi"; +import { ApiBase } from "#app/plugins/api/api-base"; + +export class PokerogueAdminApi extends ApiBase { + public readonly ERR_USERNAME_NOT_FOUND: string = "Username not found!"; + + /** + * Links an account to a discord id. + * @param params The {@linkcode LinkAccountToDiscordIdRequest} to send + * @returns `null` if successful, error message if not + */ + public async linkAccountToDiscord(params: LinkAccountToDiscordIdRequest) { + try { + const response = await this.doPost("/admin/account/discordLink", params, "form-urlencoded"); + + if (response.ok) { + return null; + } else { + console.warn("Could not link account with discord!", response.status, response.statusText); + + if (response.status === 404) { + return this.ERR_USERNAME_NOT_FOUND; + } + } + } catch (err) { + console.warn("Could not link account with discord!", err); + } + + return this.ERR_GENERIC; + } + + /** + * Unlinks an account from a discord id. + * @param params The {@linkcode UnlinkAccountFromDiscordIdRequest} to send + * @returns `null` if successful, error message if not + */ + public async unlinkAccountFromDiscord(params: UnlinkAccountFromDiscordIdRequest) { + try { + const response = await this.doPost("/admin/account/discordUnlink", params, "form-urlencoded"); + + if (response.ok) { + return null; + } else { + console.warn("Could not unlink account from discord!", response.status, response.statusText); + + if (response.status === 404) { + return this.ERR_USERNAME_NOT_FOUND; + } + } + } catch (err) { + console.warn("Could not unlink account from discord!", err); + } + + return this.ERR_GENERIC; + } + + /** + * Links an account to a google id. + * @param params The {@linkcode LinkAccountToGoogledIdRequest} to send + * @returns `null` if successful, error message if not + */ + public async linkAccountToGoogleId(params: LinkAccountToGoogledIdRequest) { + try { + const response = await this.doPost("/admin/account/googleLink", params, "form-urlencoded"); + + if (response.ok) { + return null; + } else { + console.warn("Could not link account with google!", response.status, response.statusText); + + if (response.status === 404) { + return this.ERR_USERNAME_NOT_FOUND; + } + } + } catch (err) { + console.warn("Could not link account with google!", err); + } + + return this.ERR_GENERIC; + } + + /** + * Unlinks an account from a google id. + * @param params The {@linkcode UnlinkAccountFromGoogledIdRequest} to send + * @returns `null` if successful, error message if not + */ + public async unlinkAccountFromGoogleId(params: UnlinkAccountFromGoogledIdRequest) { + try { + const response = await this.doPost("/admin/account/googleUnlink", params, "form-urlencoded"); + + if (response.ok) { + return null; + } else { + console.warn("Could not unlink account from google!", response.status, response.statusText); + + if (response.status === 404) { + return this.ERR_USERNAME_NOT_FOUND; + } + } + } catch (err) { + console.warn("Could not unlink account from google!", err); + } + + return this.ERR_GENERIC; + } + + /** + * Search an account. + * @param params The {@linkcode SearchAccountRequest} to send + * @returns an array of {@linkcode SearchAccountResponse} and error. Both can be `undefined` + */ + public async searchAccount(params: SearchAccountRequest): Promise<[data?: SearchAccountResponse, error?: string]> { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/admin/account/adminSearch?${urlSearchParams}`); + + if (response.ok) { + const resData: SearchAccountResponse = await response.json(); + return [ resData, undefined ]; + } else { + console.warn("Could not find account!", response.status, response.statusText); + + if (response.status === 404) { + return [ undefined, this.ERR_USERNAME_NOT_FOUND ]; + } + } + } catch (err) { + console.warn("Could not find account!", err); + } + + return [ undefined, this.ERR_GENERIC ]; + } +} diff --git a/src/plugins/api/pokerogue-api.ts b/src/plugins/api/pokerogue-api.ts new file mode 100644 index 00000000000..92d0ff1bbbb --- /dev/null +++ b/src/plugins/api/pokerogue-api.ts @@ -0,0 +1,83 @@ +import type { TitleStatsResponse } from "#app/@types/PokerogueApi"; +import { ApiBase } from "#app/plugins/api/api-base"; +import { PokerogueAccountApi } from "#app/plugins/api/pokerogue-account-api"; +import { PokerogueAdminApi } from "#app/plugins/api/pokerogue-admin-api"; +import { PokerogueDailyApi } from "#app/plugins/api/pokerogue-daily-api"; +import { PokerogueSavedataApi } from "#app/plugins/api/pokerogue-savedata-api"; + +/** + * A wrapper for PokéRogue API requests. + */ +export class PokerogueApi extends ApiBase { + //#region Fields∏ + + public readonly account: PokerogueAccountApi; + public readonly daily: PokerogueDailyApi; + public readonly admin: PokerogueAdminApi; + public readonly savedata: PokerogueSavedataApi; + + //#region Public + + constructor(base: string) { + super(base); + this.account = new PokerogueAccountApi(base); + this.daily = new PokerogueDailyApi(base); + this.admin = new PokerogueAdminApi(base); + this.savedata = new PokerogueSavedataApi(base); + } + + /** + * Request game title-stats. + */ + public async getGameTitleStats() { + try { + const response = await this.doGet("/game/titlestats"); + return (await response.json()) as TitleStatsResponse; + } catch (err) { + console.warn("Could not get game title stats!", err); + return null; + } + } + + /** + * Unlink the currently logged in user from Discord. + * @returns `true` if unlinking was successful, `false` if not + */ + public async unlinkDiscord() { + try { + const response = await this.doPost("/auth/discord/logout"); + if (response.ok) { + return true; + } else { + console.warn(`Discord unlink failed (${response.status}: ${response.statusText})`); + } + } catch (err) { + console.warn("Could not unlink Discord!", err); + } + + return false; + } + + /** + * Unlink the currently logged in user from Google. + * @returns `true` if unlinking was successful, `false` if not + */ + public async unlinkGoogle() { + try { + const response = await this.doPost("/auth/google/logout"); + if (response.ok) { + return true; + } else { + console.warn(`Google unlink failed (${response.status}: ${response.statusText})`); + } + } catch (err) { + console.warn("Could not unlink Google!", err); + } + + return false; + } + + //#endregion +} + +export const pokerogueApi = new PokerogueApi(import.meta.env.VITE_SERVER_URL ?? "http://localhost:8001"); diff --git a/src/plugins/api/pokerogue-daily-api.ts b/src/plugins/api/pokerogue-daily-api.ts new file mode 100644 index 00000000000..c9319ae7fdc --- /dev/null +++ b/src/plugins/api/pokerogue-daily-api.ts @@ -0,0 +1,57 @@ +import type { GetDailyRankingsPageCountRequest, GetDailyRankingsRequest } from "#app/@types/PokerogueDailyApi"; +import { ApiBase } from "#app/plugins/api/api-base"; +import type { RankingEntry } from "#app/ui/daily-run-scoreboard"; + +/** + * A wrapper for daily-run PokéRogue API requests. + */ +export class PokerogueDailyApi extends ApiBase { + //#region Public + + /** + * Request the daily-run seed. + * @returns The active daily-run seed as `string`. + */ + public async getSeed() { + try { + const response = await this.doGet("/daily/seed"); + return response.text(); + } catch (err) { + console.warn("Could not get daily-run seed!", err); + return null; + } + } + + /** + * Get the daily rankings for a {@linkcode ScoreboardCategory}. + * @param params The {@linkcode GetDailyRankingsRequest} to send + */ + public async getRankings(params: GetDailyRankingsRequest) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/daily/rankings?${urlSearchParams}`); + + return (await response.json()) as RankingEntry[]; + } catch (err) { + console.warn("Could not get daily rankings!", err); + return null; + } + } + + /** + * Get the page count of the daily rankings for a {@linkcode ScoreboardCategory}. + * @param params The {@linkcode GetDailyRankingsPageCountRequest} to send. + */ + public async getRankingsPageCount(params: GetDailyRankingsPageCountRequest) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/daily/rankingpagecount?${urlSearchParams}`); + const json = await response.json(); + + return Number(json); + } catch (err) { + console.warn("Could not get daily rankings page count!", err); + return 1; + } + } +} diff --git a/src/plugins/api/pokerogue-savedata-api.ts b/src/plugins/api/pokerogue-savedata-api.ts new file mode 100644 index 00000000000..184bfbb4bdb --- /dev/null +++ b/src/plugins/api/pokerogue-savedata-api.ts @@ -0,0 +1,41 @@ +import type { UpdateAllSavedataRequest } from "#app/@types/PokerogueSavedataApi"; +import { MAX_INT_ATTR_VALUE } from "#app/constants"; +import { ApiBase } from "#app/plugins/api/api-base"; +import { PokerogueSessionSavedataApi } from "#app/plugins/api/pokerogue-session-savedata-api"; +import { PokerogueSystemSavedataApi } from "#app/plugins/api/pokerogue-system-savedata-api"; + +/** + * A wrapper for PokéRogue savedata API requests. + */ +export class PokerogueSavedataApi extends ApiBase { + //#region Fields + + public readonly system: PokerogueSystemSavedataApi; + public readonly session: PokerogueSessionSavedataApi; + + //#region Public + + constructor(base: string) { + super(base); + this.system = new PokerogueSystemSavedataApi(base); + this.session = new PokerogueSessionSavedataApi(base); + } + + /** + * Update all savedata + * @param bodyData The {@linkcode UpdateAllSavedataRequest | request data} to send + * @returns An error message if something went wrong + */ + public async updateAll(bodyData: UpdateAllSavedataRequest) { + try { + const rawBodyData = JSON.stringify(bodyData, (_k: any, v: any) => + typeof v === "bigint" ? (v <= MAX_INT_ATTR_VALUE ? Number(v) : v.toString()) : v + ); + const response = await this.doPost("/savedata/updateall", rawBodyData); + return await response.text(); + } catch (err) { + console.warn("Could not update all savedata!", err); + return "Unknown error"; + } + } +} diff --git a/src/plugins/api/pokerogue-session-savedata-api.ts b/src/plugins/api/pokerogue-session-savedata-api.ts new file mode 100644 index 00000000000..44a7b463849 --- /dev/null +++ b/src/plugins/api/pokerogue-session-savedata-api.ts @@ -0,0 +1,115 @@ +import type { + ClearSessionSavedataRequest, + ClearSessionSavedataResponse, + DeleteSessionSavedataRequest, + GetSessionSavedataRequest, + NewClearSessionSavedataRequest, + UpdateSessionSavedataRequest, +} from "#app/@types/PokerogueSessionSavedataApi"; +import { ApiBase } from "#app/plugins/api/api-base"; +import type { SessionSaveData } from "#app/system/game-data"; + +/** + * A wrapper for PokéRogue session savedata API requests. + */ +export class PokerogueSessionSavedataApi extends ApiBase { + //#region Public + + /** + * Mark a session as cleared aka "newclear".\ + * *This is **NOT** the same as {@linkcode clear | clear()}.* + * @param params The {@linkcode NewClearSessionSavedataRequest} to send + * @returns The raw savedata as `string`. + */ + public async newclear(params: NewClearSessionSavedataRequest) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/savedata/session/newclear?${urlSearchParams}`); + const json = await response.json(); + + return Boolean(json); + } catch (err) { + console.warn("Could not newclear session!", err); + return false; + } + } + + /** + * Get a session savedata. + * @param params The {@linkcode GetSessionSavedataRequest} to send + * @returns The session as `string` + */ + public async get(params: GetSessionSavedataRequest) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/savedata/session/get?${urlSearchParams}`); + + return await response.text(); + } catch (err) { + console.warn("Could not get session savedata!", err); + return null; + } + } + + /** + * Update a session savedata. + * @param params The {@linkcode UpdateSessionSavedataRequest} to send + * @param rawSavedata The raw savedata (as `string`) + * @returns An error message if something went wrong + */ + public async update(params: UpdateSessionSavedataRequest, rawSavedata: string) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doPost(`/savedata/session/update?${urlSearchParams}`, rawSavedata); + + return await response.text(); + } catch (err) { + console.warn("Could not update session savedata!", err); + } + + return "Unknown Error!"; + } + + /** + * Delete a session savedata slot. + * @param params The {@linkcode DeleteSessionSavedataRequest} to send + * @returns An error message if something went wrong + */ + public async delete(params: DeleteSessionSavedataRequest) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/savedata/session/delete?${urlSearchParams}`); + + if (response.ok) { + return null; + } else { + return await response.text(); + } + } catch (err) { + console.warn("Could not delete session savedata!", err); + return "Unknown error"; + } + } + + /** + * Clears the session savedata of the given slot.\ + * *This is **NOT** the same as {@linkcode newclear | newclear()}.* + * @param params The {@linkcode ClearSessionSavedataRequest} to send + * @param sessionData The {@linkcode SessionSaveData} object + */ + public async clear(params: ClearSessionSavedataRequest, sessionData: SessionSaveData) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doPost(`/savedata/session/clear?${urlSearchParams}`, sessionData); + + return (await response.json()) as ClearSessionSavedataResponse; + } catch (err) { + console.warn("Could not clear session savedata!", err); + } + + return { + error: "Unknown error", + success: false, + } as ClearSessionSavedataResponse; + } +} diff --git a/src/plugins/api/pokerogue-system-savedata-api.ts b/src/plugins/api/pokerogue-system-savedata-api.ts new file mode 100644 index 00000000000..659584776c4 --- /dev/null +++ b/src/plugins/api/pokerogue-system-savedata-api.ts @@ -0,0 +1,77 @@ +import type { + GetSystemSavedataRequest, + UpdateSystemSavedataRequest, + VerifySystemSavedataRequest, + VerifySystemSavedataResponse, +} from "#app/@types/PokerogueSystemSavedataApi"; +import { ApiBase } from "#app/plugins/api/api-base"; + +/** + * A wrapper for PokéRogue system savedata API requests. + */ +export class PokerogueSystemSavedataApi extends ApiBase { + //#region Public + + /** + * Get a system savedata. + * @param params The {@linkcode GetSystemSavedataRequest} to send + * @returns The system savedata as `string` or `null` on error + */ + public async get(params: GetSystemSavedataRequest) { + try { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/savedata/system/get?${urlSearchParams}`); + const rawSavedata = await response.text(); + + return rawSavedata; + } catch (err) { + console.warn("Could not get system savedata!", err); + return null; + } + } + + /** + * Verify if the session is valid. + * If not the {@linkcode SystemSaveData} is returned. + * @param params The {@linkcode VerifySystemSavedataRequest} to send + * @returns A {@linkcode SystemSaveData} if **NOT** valid, otherwise `null`. + * + * TODO: add handling for errors + */ + public async verify(params: VerifySystemSavedataRequest) { + const urlSearchParams = this.toUrlSearchParams(params); + const response = await this.doGet(`/savedata/system/verify?${urlSearchParams}`); + + if (response.ok) { + const verifySavedata = (await response.json()) as VerifySystemSavedataResponse; + + if (!verifySavedata.valid) { + console.warn("Invalid system savedata!"); + return verifySavedata.systemData; + } + } else { + console.warn("System savedata verification failed!", response.status, response.statusText); + } + + return null; + } + + /** + * Update a system savedata. + * @param params The {@linkcode UpdateSystemSavedataRequest} to send + * @param rawSystemData The raw {@linkcode SystemSaveData} + * @returns An error message if something went wrong + */ + public async update(params: UpdateSystemSavedataRequest, rawSystemData: string) { + try { + const urSearchParams = this.toUrlSearchParams(params); + const response = await this.doPost(`/savedata/system/update?${urSearchParams}`, rawSystemData); + + return await response.text(); + } catch (err) { + console.warn("Could not update system savedata!", err); + } + + return "Unknown Error"; + } +} diff --git a/src/system/game-data.ts b/src/system/game-data.ts index e252e03afaf..4b7eeedfe77 100644 --- a/src/system/game-data.ts +++ b/src/system/game-data.ts @@ -48,7 +48,7 @@ import { RUN_HISTORY_LIMIT } from "#app/ui/run-history-ui-handler"; import { applySessionVersionMigration, applySystemVersionMigration, applySettingsVersionMigration } from "./version_migration/version_converter"; import { MysteryEncounterSaveData } from "#app/data/mystery-encounters/mystery-encounter-save-data"; import { MysteryEncounterType } from "#enums/mystery-encounter-type"; -import { PokerogueApiClearSessionData } from "#app/@types/pokerogue-api"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; import { ArenaTrapTag } from "#app/data/arena-tag"; export const defaultStarterSpecies: Species[] = [ @@ -397,8 +397,7 @@ export class GameData { localStorage.setItem(`data_${loggedInUser?.username}`, encrypt(systemData, bypassLogin)); if (!bypassLogin) { - Utils.apiPost(`savedata/system/update?clientSessionId=${clientSessionId}`, systemData, undefined, true) - .then(response => response.text()) + pokerogueApi.savedata.system.update({ clientSessionId }, systemData) .then(error => { this.scene.ui.savingIcon.hide(); if (error) { @@ -428,23 +427,22 @@ export class GameData { } if (!bypassLogin) { - Utils.apiFetch(`savedata/system/get?clientSessionId=${clientSessionId}`, true) - .then(response => response.text()) - .then(response => { - if (!response.length || response[0] !== "{") { - if (response.startsWith("sql: no rows in result set")) { + pokerogueApi.savedata.system.get({ clientSessionId }) + .then(saveDataOrErr => { + if (!saveDataOrErr || saveDataOrErr.length === 0 || saveDataOrErr[0] !== "{") { + if (saveDataOrErr?.startsWith("sql: no rows in result set")) { this.scene.queueMessage("Save data could not be found. If this is a new account, you can safely ignore this message.", null, true); return resolve(true); - } else if (response.indexOf("Too many connections") > -1) { + } else if (saveDataOrErr?.includes("Too many connections")) { this.scene.queueMessage("Too many people are trying to connect and the server is overloaded. Please try again later.", null, true); return resolve(false); } - console.error(response); + console.error(saveDataOrErr); return resolve(false); } const cachedSystem = localStorage.getItem(`data_${loggedInUser?.username}`); - this.initSystem(response, cachedSystem ? AES.decrypt(cachedSystem, saveKey).toString(enc.Utf8) : undefined).then(resolve); + this.initSystem(saveDataOrErr, cachedSystem ? AES.decrypt(cachedSystem, saveKey).toString(enc.Utf8) : undefined).then(resolve); }); } else { this.initSystem(decrypt(localStorage.getItem(`data_${loggedInUser?.username}`)!, bypassLogin)).then(resolve); // TODO: is this bang correct? @@ -580,6 +578,7 @@ export class GameData { if (!Utils.isLocal) { /** * Networking Code DO NOT DELETE! + * Note: Might have to be migrated to `pokerogue-api.ts` * const response = await Utils.apiFetch("savedata/runHistory", true); const data = await response.json(); @@ -660,6 +659,7 @@ export class GameData { return false; } } + NOTE: should be adopted to `pokerogue-api.ts` */ return true; } @@ -704,12 +704,11 @@ export class GameData { return true; } - const response = await Utils.apiFetch(`savedata/system/verify?clientSessionId=${clientSessionId}`, true) - .then(response => response.json()); + const systemData = await pokerogueApi.savedata.system.verify({ clientSessionId }); - if (!response.valid) { + if (systemData) { this.scene.clearPhaseQueue(); - this.scene.unshiftPhase(new ReloadSessionPhase(this.scene, JSON.stringify(response.systemData))); + this.scene.unshiftPhase(new ReloadSessionPhase(this.scene, JSON.stringify(systemData))); this.clearLocalData(); return false; } @@ -984,10 +983,9 @@ export class GameData { }; if (!bypassLogin && !localStorage.getItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`)) { - Utils.apiFetch(`savedata/session/get?slot=${slotId}&clientSessionId=${clientSessionId}`, true) - .then(response => response.text()) + pokerogueApi.savedata.session.get({ slot: slotId, clientSessionId }) .then(async response => { - if (!response.length || response[0] !== "{") { + if (!response || response?.length === 0 || response?.[0] !== "{") { console.error(response); return resolve(null); } @@ -1149,14 +1147,7 @@ export class GameData { if (success !== null && !success) { return resolve(false); } - Utils.apiFetch(`savedata/session/delete?slot=${slotId}&clientSessionId=${clientSessionId}`, true).then(response => { - if (response.ok) { - loggedInUser!.lastSessionSlot = -1; // TODO: is the bang correct? - localStorage.removeItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`); - resolve(true); - } - return response.text(); - }).then(error => { + pokerogueApi.savedata.session.delete({ slot: slotId, clientSessionId }).then(error => { if (error) { if (error.startsWith("session out of date")) { this.scene.clearPhaseQueue(); @@ -1164,8 +1155,15 @@ export class GameData { } console.error(error); resolve(false); + } else { + if (loggedInUser) { + loggedInUser.lastSessionSlot = -1; + } + + localStorage.removeItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`); + resolve(true); + } - resolve(true); }); }); }); @@ -1215,17 +1213,15 @@ export class GameData { result = [ true, true ]; } else { const sessionData = this.getSessionSaveData(scene); - const response = await Utils.apiPost(`savedata/session/clear?slot=${slotId}&trainerId=${this.trainerId}&secretId=${this.secretId}&clientSessionId=${clientSessionId}`, JSON.stringify(sessionData), undefined, true); + const { trainerId } = this; + const jsonResponse = await pokerogueApi.savedata.session.clear({ slot: slotId, trainerId, clientSessionId }, sessionData); - if (response.ok) { - loggedInUser!.lastSessionSlot = -1; // TODO: is the bang correct? - localStorage.removeItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`); - } - - const jsonResponse: PokerogueApiClearSessionData = await response.json(); - - if (!jsonResponse.error) { - result = [ true, jsonResponse.success ?? false ]; + if (!jsonResponse?.error) { + result = [ true, jsonResponse?.success ?? false ]; + if (loggedInUser) { + loggedInUser!.lastSessionSlot = -1; + } + localStorage.removeItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`); } else { if (jsonResponse && jsonResponse.error?.startsWith("session out of date")) { this.scene.clearPhaseQueue(); @@ -1342,8 +1338,7 @@ export class GameData { console.debug("Session data saved"); if (!bypassLogin && sync) { - Utils.apiPost("savedata/updateall", JSON.stringify(request, (k: any, v: any) => typeof v === "bigint" ? v <= maxIntAttrValue ? Number(v) : v.toString() : v), undefined, true) - .then(response => response.text()) + pokerogueApi.savedata.updateAll(request) .then(error => { if (sync) { this.scene.lastSavePlayTime = 0; @@ -1387,18 +1382,24 @@ export class GameData { link.remove(); }; if (!bypassLogin && dataType < GameDataType.SETTINGS) { - Utils.apiFetch(`savedata/${dataType === GameDataType.SYSTEM ? "system" : "session"}/get?clientSessionId=${clientSessionId}${dataType === GameDataType.SESSION ? `&slot=${slotId}` : ""}`, true) - .then(response => response.text()) - .then(response => { - if (!response.length || response[0] !== "{") { - console.error(response); - resolve(false); - return; - } + let promise: Promise = Promise.resolve(null); - handleData(response); - resolve(true); - }); + if (dataType === GameDataType.SYSTEM) { + promise = pokerogueApi.savedata.system.get({ clientSessionId }); + } else if (dataType === GameDataType.SESSION) { + promise = pokerogueApi.savedata.session.get({ slot: slotId, clientSessionId }); + } + + promise.then(response => { + if (!response?.length || response[0] !== "{") { + console.error(response); + resolve(false); + return; + } + + handleData(response); + resolve(true); + }); } else { const data = localStorage.getItem(dataKey); if (data) { @@ -1477,14 +1478,14 @@ export class GameData { if (!success[0]) { return displayError(`Could not contact the server. Your ${dataName} data could not be imported.`); } - let url: string; + const { trainerId, secretId } = this; + let updatePromise: Promise; if (dataType === GameDataType.SESSION) { - url = `savedata/session/update?slot=${slotId}&trainerId=${this.trainerId}&secretId=${this.secretId}&clientSessionId=${clientSessionId}`; + updatePromise = pokerogueApi.savedata.session.update({ slot: slotId, trainerId, secretId, clientSessionId }, dataStr); } else { - url = `savedata/system/update?trainerId=${this.trainerId}&secretId=${this.secretId}&clientSessionId=${clientSessionId}`; + updatePromise = pokerogueApi.savedata.system.update({ trainerId, secretId, clientSessionId }, dataStr); } - Utils.apiPost(url, dataStr, undefined, true) - .then(response => response.text()) + updatePromise .then(error => { if (error) { console.error(error); diff --git a/src/test/account.test.ts b/src/test/account.test.ts index 8c36f2cd953..0f49014c377 100644 --- a/src/test/account.test.ts +++ b/src/test/account.test.ts @@ -1,7 +1,7 @@ import * as battleScene from "#app/battle-scene"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; import { describe, expect, it, vi } from "vitest"; import { initLoggedInUser, loggedInUser, updateUserInfo } from "../account"; -import * as utils from "../utils"; describe("account", () => { describe("initLoggedInUser", () => { @@ -27,17 +27,16 @@ describe("account", () => { it("should fetch user info from the API if bypassLogin is false", async () => { vi.spyOn(battleScene, "bypassLogin", "get").mockReturnValue(false); - vi.spyOn(utils, "apiFetch").mockResolvedValue( - new Response( - JSON.stringify({ - username: "test", - lastSessionSlot: 99, - }), - { - status: 200, - } - ) - ); + vi.spyOn(pokerogueApi.account, "getInfo").mockResolvedValue([ + { + username: "test", + lastSessionSlot: 99, + discordId: "", + googleId: "", + hasAdminRole: false, + }, + 200, + ]); const [ success, status ] = await updateUserInfo(); @@ -49,9 +48,7 @@ describe("account", () => { it("should handle resolved API errors", async () => { vi.spyOn(battleScene, "bypassLogin", "get").mockReturnValue(false); - vi.spyOn(utils, "apiFetch").mockResolvedValue( - new Response(null, { status: 401 }) - ); + vi.spyOn(pokerogueApi.account, "getInfo").mockResolvedValue([ null, 401 ]); const [ success, status ] = await updateUserInfo(); @@ -59,16 +56,14 @@ describe("account", () => { expect(status).toBe(401); }); - it("should handle rejected API errors", async () => { - const consoleErrorSpy = vi.spyOn(console, "error"); + it("should handle 500 API errors", async () => { vi.spyOn(battleScene, "bypassLogin", "get").mockReturnValue(false); - vi.spyOn(utils, "apiFetch").mockRejectedValue(new Error("Api failed!")); + vi.spyOn(pokerogueApi.account, "getInfo").mockResolvedValue([ null, 500 ]); const [ success, status ] = await updateUserInfo(); expect(success).toBe(false); expect(status).toBe(500); - expect(consoleErrorSpy).toHaveBeenCalled(); }); }); }); diff --git a/src/test/daily_mode.test.ts b/src/test/daily_mode.test.ts index 2a88ce10ae7..3e70cc2d8a7 100644 --- a/src/test/daily_mode.test.ts +++ b/src/test/daily_mode.test.ts @@ -1,11 +1,12 @@ -import { MapModifier } from "#app/modifier/modifier"; -import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest"; -import GameManager from "./utils/gameManager"; -import { Moves } from "#app/enums/moves"; import { Biome } from "#app/enums/biome"; -import { Mode } from "#app/ui/ui"; +import { Moves } from "#app/enums/moves"; +import { MapModifier } from "#app/modifier/modifier"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; import ModifierSelectUiHandler from "#app/ui/modifier-select-ui-handler"; import { Species } from "#enums/species"; +import { Mode } from "#app/ui/ui"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; +import GameManager from "#app/test/utils/gameManager"; //const TIMEOUT = 20 * 1000; @@ -21,6 +22,7 @@ describe("Daily Mode", () => { beforeEach(() => { game = new GameManager(phaserGame); + vi.spyOn(pokerogueApi.daily, "getSeed").mockResolvedValue("test-seed"); }); afterEach(() => { @@ -32,7 +34,7 @@ describe("Daily Mode", () => { const party = game.scene.getPlayerParty(); expect(party).toHaveLength(3); - party.forEach(pkm => { + party.forEach((pkm) => { expect(pkm.level).toBe(20); expect(pkm.moveset.length).toBeGreaterThan(0); }); @@ -63,6 +65,7 @@ describe("Shop modifications", async () => { game.modifiers .addCheck("EVIOLITE") .addCheck("MINI_BLACK_HOLE"); + vi.spyOn(pokerogueApi.daily, "getSeed").mockResolvedValue("test-seed"); }); afterEach(() => { diff --git a/src/test/misc.test.ts b/src/test/misc.test.ts index 3335c4c5523..ae91a5014d9 100644 --- a/src/test/misc.test.ts +++ b/src/test/misc.test.ts @@ -1,4 +1,4 @@ -import { apiFetch } from "#app/utils"; +// import { apiFetch } from "#app/utils"; import GameManager from "#test/utils/gameManager"; import { waitUntil } from "#test/utils/gameManagerUtils"; import Phaser from "phaser"; @@ -35,18 +35,18 @@ describe("Test misc", () => { expect(spy).toHaveBeenCalled(); }); - it("test apifetch mock async", async () => { - const spy = vi.fn(); - await apiFetch("https://localhost:8080/account/info").then(response => { - expect(response.status).toBe(200); - expect(response.ok).toBe(true); - return response.json(); - }).then(data => { - spy(); // Call the spy function - expect(data).toEqual({ "username": "greenlamp", "lastSessionSlot": 0 }); - }); - expect(spy).toHaveBeenCalled(); - }); + // it.skip("test apifetch mock async", async () => { + // const spy = vi.fn(); + // await apiFetch("https://localhost:8080/account/info").then(response => { + // expect(response.status).toBe(200); + // expect(response.ok).toBe(true); + // return response.json(); + // }).then(data => { + // spy(); // Call the spy function + // expect(data).toEqual({ "username": "greenlamp", "lastSessionSlot": 0 }); + // }); + // expect(spy).toHaveBeenCalled(); + // }); it("test fetch mock sync", async () => { const response = await fetch("https://localhost:8080/account/info"); diff --git a/src/test/plugins/api/pokerogue-account-api.test.ts b/src/test/plugins/api/pokerogue-account-api.test.ts new file mode 100644 index 00000000000..90a7d3639ad --- /dev/null +++ b/src/test/plugins/api/pokerogue-account-api.test.ts @@ -0,0 +1,157 @@ +import type { AccountInfoResponse } from "#app/@types/PokerogueAccountApi"; +import { SESSION_ID_COOKIE_NAME } from "#app/constants"; +import { PokerogueAccountApi } from "#app/plugins/api/pokerogue-account-api"; +import { getApiBaseUrl } from "#app/test/utils/testUtils"; +import * as Utils from "#app/utils"; +import { http, HttpResponse } from "msw"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const apiBase = getApiBaseUrl(); +const accountApi = new PokerogueAccountApi(apiBase); +const { server } = global; + +afterEach(() => { + server.resetHandlers(); +}); + +describe("Pokerogue Account API", () => { + beforeEach(() => { + vi.spyOn(console, "warn"); + }); + + describe("Get Info", () => { + it("should return account-info & 200 on SUCCESS", async () => { + const expectedAccountInfo: AccountInfoResponse = { + username: "test", + lastSessionSlot: -1, + discordId: "23235353543535", + googleId: "1ed1d1d11d1d1d1d1d1", + hasAdminRole: false, + }; + server.use(http.get(`${apiBase}/account/info`, () => HttpResponse.json(expectedAccountInfo))); + + const [ accountInfo, status ] = await accountApi.getInfo(); + + expect(accountInfo).toEqual(expectedAccountInfo); + expect(status).toBe(200); + }); + + it("should return null + status-code anad report a warning on FAILURE", async () => { + server.use(http.get(`${apiBase}/account/info`, () => new HttpResponse("", { status: 401 }))); + + const [ accountInfo, status ] = await accountApi.getInfo(); + + expect(accountInfo).toBeNull(); + expect(status).toBe(401); + expect(console.warn).toHaveBeenCalledWith("Could not get account info!", 401, "Unauthorized"); + }); + + it("should return null + 500 anad report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/account/info`, () => HttpResponse.error())); + + const [ accountInfo, status ] = await accountApi.getInfo(); + + expect(accountInfo).toBeNull(); + expect(status).toBe(500); + expect(console.warn).toHaveBeenCalledWith("Could not get account info!", expect.any(Error)); + }); + }); + + describe("Register", () => { + const registerParams = { username: "test", password: "test" }; + + it("should return null on SUCCESS", async () => { + server.use(http.post(`${apiBase}/account/register`, () => HttpResponse.text())); + + const error = await accountApi.register(registerParams); + + expect(error).toBeNull(); + }); + + it("should return error message on FAILURE", async () => { + server.use( + http.post(`${apiBase}/account/register`, () => new HttpResponse("Username is already taken", { status: 400 })) + ); + + const error = await accountApi.register(registerParams); + + expect(error).toBe("Username is already taken"); + }); + + it("should return \"Unknown error\" and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/account/register`, () => HttpResponse.error())); + + const error = await accountApi.register(registerParams); + + expect(error).toBe("Unknown error!"); + expect(console.warn).toHaveBeenCalledWith("Register failed!", expect.any(Error)); + }); + }); + + describe("Login", () => { + const loginParams = { username: "test", password: "test" }; + + it("should return null and set the cookie on SUCCESS", async () => { + vi.spyOn(Utils, "setCookie"); + server.use(http.post(`${apiBase}/account/login`, () => HttpResponse.json({ token: "abctest" }))); + + const error = await accountApi.login(loginParams); + + expect(error).toBeNull(); + expect(Utils.setCookie).toHaveBeenCalledWith(SESSION_ID_COOKIE_NAME, "abctest"); + }); + + it("should return error message and report a warning on FAILURE", async () => { + server.use( + http.post(`${apiBase}/account/login`, () => new HttpResponse("Password is incorrect", { status: 401 })) + ); + + const error = await accountApi.login(loginParams); + + expect(error).toBe("Password is incorrect"); + expect(console.warn).toHaveBeenCalledWith("Login failed!", 401, "Unauthorized"); + }); + + it("should return \"Unknown error\" and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/account/login`, () => HttpResponse.error())); + + const error = await accountApi.login(loginParams); + + expect(error).toBe("Unknown error!"); + expect(console.warn).toHaveBeenCalledWith("Login failed!", expect.any(Error)); + }); + }); + + describe("Logout", () => { + beforeEach(() => { + vi.spyOn(Utils, "removeCookie"); + }); + + it("should remove cookie on success", async () => { + vi.spyOn(Utils, "setCookie"); + server.use(http.get(`${apiBase}/account/logout`, () => new HttpResponse("", { status: 200 }))); + + await accountApi.logout(); + + expect(Utils.removeCookie).toHaveBeenCalledWith(SESSION_ID_COOKIE_NAME); + }); + + it("should report a warning on and remove cookie on FAILURE", async () => { + server.use(http.get(`${apiBase}/account/logout`, () => new HttpResponse("", { status: 401 }))); + + await accountApi.logout(); + + expect(Utils.removeCookie).toHaveBeenCalledWith(SESSION_ID_COOKIE_NAME); + expect(console.warn).toHaveBeenCalledWith("Log out failed!", expect.any(Error)); + }); + + it("should report a warning on and remove cookie on ERROR", async () => { + server.use(http.get(`${apiBase}/account/logout`, () => HttpResponse.error())); + + await accountApi.logout(); + + expect(Utils.removeCookie).toHaveBeenCalledWith(SESSION_ID_COOKIE_NAME); + expect(console.warn).toHaveBeenCalledWith("Log out failed!", expect.any(Error)); + }); + }); +}); diff --git a/src/test/plugins/api/pokerogue-admin-api.test.ts b/src/test/plugins/api/pokerogue-admin-api.test.ts new file mode 100644 index 00000000000..5ae46abfcc8 --- /dev/null +++ b/src/test/plugins/api/pokerogue-admin-api.test.ts @@ -0,0 +1,232 @@ +import type { + LinkAccountToDiscordIdRequest, + LinkAccountToGoogledIdRequest, + SearchAccountRequest, + SearchAccountResponse, + UnlinkAccountFromDiscordIdRequest, + UnlinkAccountFromGoogledIdRequest, +} from "#app/@types/PokerogueAdminApi"; +import { PokerogueAdminApi } from "#app/plugins/api/pokerogue-admin-api"; +import { getApiBaseUrl } from "#app/test/utils/testUtils"; +import { http, HttpResponse } from "msw"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const apiBase = getApiBaseUrl(); +const adminApi = new PokerogueAdminApi(apiBase); +const { server } = global; + +afterEach(() => { + server.resetHandlers(); +}); + +describe("Pokerogue Admin API", () => { + beforeEach(() => { + vi.spyOn(console, "warn"); + }); + + describe("Link Account to Discord", () => { + const params: LinkAccountToDiscordIdRequest = { username: "test", discordId: "test-12575756" }; + + it("should return null on SUCCESS", async () => { + server.use(http.post(`${apiBase}/admin/account/discordLink`, () => HttpResponse.json(true))); + + const success = await adminApi.linkAccountToDiscord(params); + + expect(success).toBeNull(); + }); + + it("should return a ERR_GENERIC and report a warning on FAILURE", async () => { + server.use(http.post(`${apiBase}/admin/account/discordLink`, () => new HttpResponse("", { status: 400 }))); + + const success = await adminApi.linkAccountToDiscord(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not link account with discord!", 400, "Bad Request"); + }); + + it("should return a ERR_USERNAME_NOT_FOUND and report a warning on 404", async () => { + server.use(http.post(`${apiBase}/admin/account/discordLink`, () => new HttpResponse("", { status: 404 }))); + + const success = await adminApi.linkAccountToDiscord(params); + + expect(success).toBe(adminApi.ERR_USERNAME_NOT_FOUND); + expect(console.warn).toHaveBeenCalledWith("Could not link account with discord!", 404, "Not Found"); + }); + + it("should return a ERR_GENERIC and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/admin/account/discordLink`, () => HttpResponse.error())); + + const success = await adminApi.linkAccountToDiscord(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not link account with discord!", expect.any(Error)); + }); + }); + + describe("Unlink Account from Discord", () => { + const params: UnlinkAccountFromDiscordIdRequest = { username: "test", discordId: "test-12575756" }; + + it("should return null on SUCCESS", async () => { + server.use(http.post(`${apiBase}/admin/account/discordUnlink`, () => HttpResponse.json(true))); + + const success = await adminApi.unlinkAccountFromDiscord(params); + + expect(success).toBeNull(); + }); + + it("should return a ERR_GENERIC and report a warning on FAILURE", async () => { + server.use(http.post(`${apiBase}/admin/account/discordUnlink`, () => new HttpResponse("", { status: 400 }))); + + const success = await adminApi.unlinkAccountFromDiscord(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not unlink account from discord!", 400, "Bad Request"); + }); + + it("should return a ERR_USERNAME_NOT_FOUND and report a warning on 404", async () => { + server.use(http.post(`${apiBase}/admin/account/discordUnlink`, () => new HttpResponse("", { status: 404 }))); + + const success = await adminApi.unlinkAccountFromDiscord(params); + + expect(success).toBe(adminApi.ERR_USERNAME_NOT_FOUND); + expect(console.warn).toHaveBeenCalledWith("Could not unlink account from discord!", 404, "Not Found"); + }); + + it("should return a ERR_GENERIC and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/admin/account/discordUnlink`, () => HttpResponse.error())); + + const success = await adminApi.unlinkAccountFromDiscord(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not unlink account from discord!", expect.any(Error)); + }); + }); + + describe("Link Account to Google", () => { + const params: LinkAccountToGoogledIdRequest = { username: "test", googleId: "test-12575756" }; + + it("should return null on SUCCESS", async () => { + server.use(http.post(`${apiBase}/admin/account/googleLink`, () => HttpResponse.json(true))); + + const success = await adminApi.linkAccountToGoogleId(params); + + expect(success).toBeNull(); + }); + + it("should return a ERR_GENERIC and report a warning on FAILURE", async () => { + server.use(http.post(`${apiBase}/admin/account/googleLink`, () => new HttpResponse("", { status: 400 }))); + + const success = await adminApi.linkAccountToGoogleId(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not link account with google!", 400, "Bad Request"); + }); + + it("should return a ERR_USERNAME_NOT_FOUND and report a warning on 404", async () => { + server.use(http.post(`${apiBase}/admin/account/googleLink`, () => new HttpResponse("", { status: 404 }))); + + const success = await adminApi.linkAccountToGoogleId(params); + + expect(success).toBe(adminApi.ERR_USERNAME_NOT_FOUND); + expect(console.warn).toHaveBeenCalledWith("Could not link account with google!", 404, "Not Found"); + }); + + it("should return a ERR_GENERIC and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/admin/account/googleLink`, () => HttpResponse.error())); + + const success = await adminApi.linkAccountToGoogleId(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not link account with google!", expect.any(Error)); + }); + }); + + describe("Unlink Account from Google", () => { + const params: UnlinkAccountFromGoogledIdRequest = { username: "test", googleId: "test-12575756" }; + + it("should return null on SUCCESS", async () => { + server.use(http.post(`${apiBase}/admin/account/googleUnlink`, () => HttpResponse.json(true))); + + const success = await adminApi.unlinkAccountFromGoogleId(params); + + expect(success).toBeNull(); + }); + + it("should return a ERR_GENERIC and report a warning on FAILURE", async () => { + server.use(http.post(`${apiBase}/admin/account/googleUnlink`, () => new HttpResponse("", { status: 400 }))); + + const success = await adminApi.unlinkAccountFromGoogleId(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not unlink account from google!", 400, "Bad Request"); + }); + + it("should return a ERR_USERNAME_NOT_FOUND and report a warning on 404", async () => { + server.use(http.post(`${apiBase}/admin/account/googleUnlink`, () => new HttpResponse("", { status: 404 }))); + + const success = await adminApi.unlinkAccountFromGoogleId(params); + + expect(success).toBe(adminApi.ERR_USERNAME_NOT_FOUND); + expect(console.warn).toHaveBeenCalledWith("Could not unlink account from google!", 404, "Not Found"); + }); + + it("should return a ERR_GENERIC and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/admin/account/googleUnlink`, () => HttpResponse.error())); + + const success = await adminApi.unlinkAccountFromGoogleId(params); + + expect(success).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not unlink account from google!", expect.any(Error)); + }); + }); + + describe("Search Account", () => { + const params: SearchAccountRequest = { username: "test" }; + + it("should return [data, undefined] on SUCCESS", async () => { + const responseData: SearchAccountResponse = { + username: "test", + discordId: "discord-test-123", + googleId: "google-test-123", + lastLoggedIn: "2022-01-01", + registered: "2022-01-01", + }; + server.use(http.get(`${apiBase}/admin/account/adminSearch`, () => HttpResponse.json(responseData))); + + const [ data, err ] = await adminApi.searchAccount(params); + + expect(data).toStrictEqual(responseData); + expect(err).toBeUndefined(); + }); + + it("should return [undefined, ERR_GENERIC] and report a warning on on FAILURE", async () => { + server.use(http.get(`${apiBase}/admin/account/adminSearch`, () => new HttpResponse("", { status: 400 }))); + + const [ data, err ] = await adminApi.searchAccount(params); + + expect(data).toBeUndefined(); + expect(err).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not find account!", 400, "Bad Request"); + }); + + it("should return [undefined, ERR_USERNAME_NOT_FOUND] and report a warning on on 404", async () => { + server.use(http.get(`${apiBase}/admin/account/adminSearch`, () => new HttpResponse("", { status: 404 }))); + + const [ data, err ] = await adminApi.searchAccount(params); + + expect(data).toBeUndefined(); + expect(err).toBe(adminApi.ERR_USERNAME_NOT_FOUND); + expect(console.warn).toHaveBeenCalledWith("Could not find account!", 404, "Not Found"); + }); + + it("should return [undefined, ERR_GENERIC] and report a warning on on ERROR", async () => { + server.use(http.get(`${apiBase}/admin/account/adminSearch`, () => HttpResponse.error())); + + const [ data, err ] = await adminApi.searchAccount(params); + + expect(data).toBeUndefined(); + expect(err).toBe(adminApi.ERR_GENERIC); + expect(console.warn).toHaveBeenCalledWith("Could not find account!", expect.any(Error)); + }); + }); +}); diff --git a/src/test/plugins/api/pokerogue-api.test.ts b/src/test/plugins/api/pokerogue-api.test.ts new file mode 100644 index 00000000000..a62174c226d --- /dev/null +++ b/src/test/plugins/api/pokerogue-api.test.ts @@ -0,0 +1,97 @@ +import type { TitleStatsResponse } from "#app/@types/PokerogueApi"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; +import { getApiBaseUrl } from "#app/test/utils/testUtils"; +import { http, HttpResponse } from "msw"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const apiBase = getApiBaseUrl(); +const { server } = global; + +afterEach(() => { + server.resetHandlers(); +}); + +describe("Pokerogue API", () => { + beforeEach(() => { + vi.spyOn(console, "warn"); + }); + + describe("Game Title Stats", () => { + const expectedTitleStats: TitleStatsResponse = { + playerCount: 9999999, + battleCount: 9999999, + }; + + it("should return the stats on SUCCESS", async () => { + server.use(http.get(`${apiBase}/game/titlestats`, () => HttpResponse.json(expectedTitleStats))); + + const titleStats = await pokerogueApi.getGameTitleStats(); + + expect(titleStats).toEqual(expectedTitleStats); + }); + + it("should return null and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/game/titlestats`, () => HttpResponse.error())); + const titleStats = await pokerogueApi.getGameTitleStats(); + + expect(titleStats).toBeNull(); + expect(console.warn).toHaveBeenCalledWith("Could not get game title stats!", expect.any(Error)); + }); + }); + + describe("Unlink Discord", () => { + it("should return true on SUCCESS", async () => { + server.use(http.post(`${apiBase}/auth/discord/logout`, () => new HttpResponse("", { status: 200 }))); + + const success = await pokerogueApi.unlinkDiscord(); + + expect(success).toBe(true); + }); + + it("should return false and report a warning on FAILURE", async () => { + server.use(http.post(`${apiBase}/auth/discord/logout`, () => new HttpResponse("", { status: 401 }))); + + const success = await pokerogueApi.unlinkDiscord(); + + expect(success).toBe(false); + expect(console.warn).toHaveBeenCalledWith("Discord unlink failed (401: Unauthorized)"); + }); + + it("should return false and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/auth/discord/logout`, () => HttpResponse.error())); + + const success = await pokerogueApi.unlinkDiscord(); + + expect(success).toBe(false); + expect(console.warn).toHaveBeenCalledWith("Could not unlink Discord!", expect.any(Error)); + }); + }); + + describe("Unlink Google", () => { + it("should return true on SUCCESS", async () => { + server.use(http.post(`${apiBase}/auth/google/logout`, () => new HttpResponse("", { status: 200 }))); + + const success = await pokerogueApi.unlinkGoogle(); + + expect(success).toBe(true); + }); + + it("should return false and report a warning on FAILURE", async () => { + server.use(http.post(`${apiBase}/auth/google/logout`, () => new HttpResponse("", { status: 401 }))); + + const success = await pokerogueApi.unlinkGoogle(); + + expect(success).toBe(false); + expect(console.warn).toHaveBeenCalledWith("Google unlink failed (401: Unauthorized)"); + }); + + it("should return false and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/auth/google/logout`, () => HttpResponse.error())); + + const success = await pokerogueApi.unlinkGoogle(); + + expect(success).toBe(false); + expect(console.warn).toHaveBeenCalledWith("Could not unlink Google!", expect.any(Error)); + }); + }); +}); diff --git a/src/test/plugins/api/pokerogue-daily-api.test.ts b/src/test/plugins/api/pokerogue-daily-api.test.ts new file mode 100644 index 00000000000..569e7cbb15d --- /dev/null +++ b/src/test/plugins/api/pokerogue-daily-api.test.ts @@ -0,0 +1,89 @@ +import type { GetDailyRankingsPageCountRequest, GetDailyRankingsRequest } from "#app/@types/PokerogueDailyApi"; +import { PokerogueDailyApi } from "#app/plugins/api/pokerogue-daily-api"; +import { getApiBaseUrl } from "#app/test/utils/testUtils"; +import { ScoreboardCategory, type RankingEntry } from "#app/ui/daily-run-scoreboard"; +import { http, HttpResponse } from "msw"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const apiBase = getApiBaseUrl(); +const dailyApi = new PokerogueDailyApi(apiBase); +const { server } = global; + +afterEach(() => { + server.resetHandlers(); +}); + +describe("Pokerogue Daily API", () => { + beforeEach(() => { + vi.spyOn(console, "warn"); + }); + + describe("Get Seed", () => { + it("should return seed string on SUCCESS", async () => { + server.use(http.get(`${apiBase}/daily/seed`, () => HttpResponse.text("this-is-a-test-seed"))); + + const seed = await dailyApi.getSeed(); + + expect(seed).toBe("this-is-a-test-seed"); + }); + + it("should return null and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/daily/seed`, () => HttpResponse.error())); + + const seed = await dailyApi.getSeed(); + + expect(seed).toBeNull(); + expect(console.warn).toHaveBeenCalledWith("Could not get daily-run seed!", expect.any(Error)); + }); + }); + + describe("Get Rankings", () => { + const params: GetDailyRankingsRequest = { + category: ScoreboardCategory.DAILY, + }; + + it("should return ranking entries on SUCCESS", async () => { + const expectedRankings: RankingEntry[] = [ + { rank: 1, score: 999, username: "Player 1", wave: 200 }, + { rank: 2, score: 10, username: "Player 2", wave: 1 }, + ]; + server.use(http.get(`${apiBase}/daily/rankings`, () => HttpResponse.json(expectedRankings))); + + const rankings = await dailyApi.getRankings(params); + + expect(rankings).toStrictEqual(expectedRankings); + }); + + it("should return null and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/daily/rankings`, () => HttpResponse.error())); + + const rankings = await dailyApi.getRankings(params); + + expect(rankings).toBeNull(); + expect(console.warn).toHaveBeenCalledWith("Could not get daily rankings!", expect.any(Error)); + }); + }); + + describe("Get Rankings Page Count", () => { + const params: GetDailyRankingsPageCountRequest = { + category: ScoreboardCategory.DAILY, + }; + + it("should return a number on SUCCESS", async () => { + server.use(http.get(`${apiBase}/daily/rankingpagecount`, () => HttpResponse.json(5))); + + const pageCount = await dailyApi.getRankingsPageCount(params); + + expect(pageCount).toBe(5); + }); + + it("should return 1 and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/daily/rankingpagecount`, () => HttpResponse.error())); + + const pageCount = await dailyApi.getRankingsPageCount(params); + + expect(pageCount).toBe(1); + expect(console.warn).toHaveBeenCalledWith("Could not get daily rankings page count!", expect.any(Error)); + }); + }); +}); diff --git a/src/test/plugins/api/pokerogue-savedata-api.test.ts b/src/test/plugins/api/pokerogue-savedata-api.test.ts new file mode 100644 index 00000000000..6dd402206e5 --- /dev/null +++ b/src/test/plugins/api/pokerogue-savedata-api.test.ts @@ -0,0 +1,46 @@ +import type { UpdateAllSavedataRequest } from "#app/@types/PokerogueSavedataApi"; +import { PokerogueSavedataApi } from "#app/plugins/api/pokerogue-savedata-api"; +import { getApiBaseUrl } from "#app/test/utils/testUtils"; +import { http, HttpResponse } from "msw"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const apiBase = getApiBaseUrl(); +const savedataApi = new PokerogueSavedataApi(apiBase); +const { server } = global; + +afterEach(() => { + server.resetHandlers(); +}); + +describe("Pokerogue Savedata API", () => { + beforeEach(() => { + vi.spyOn(console, "warn"); + }); + + describe("Update All", () => { + it("should return an empty string on SUCCESS", async () => { + server.use(http.post(`${apiBase}/savedata/updateall`, () => HttpResponse.text(null))); + + const error = await savedataApi.updateAll({} as UpdateAllSavedataRequest); + + expect(error).toBe(""); + }); + + it("should return an error message on FAILURE", async () => { + server.use(http.post(`${apiBase}/savedata/updateall`, () => HttpResponse.text("Failed to update all!"))); + + const error = await savedataApi.updateAll({} as UpdateAllSavedataRequest); + + expect(error).toBe("Failed to update all!"); + }); + + it("should return 'Unknown error' and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/savedata/updateall`, () => HttpResponse.error())); + + const error = await savedataApi.updateAll({} as UpdateAllSavedataRequest); + + expect(error).toBe("Unknown error"); + expect(console.warn).toHaveBeenCalledWith("Could not update all savedata!", expect.any(Error)); + }); + }); +}); diff --git a/src/test/plugins/api/pokerogue-session-savedata-api.test.ts b/src/test/plugins/api/pokerogue-session-savedata-api.test.ts new file mode 100644 index 00000000000..d9f6216c4cf --- /dev/null +++ b/src/test/plugins/api/pokerogue-session-savedata-api.test.ts @@ -0,0 +1,199 @@ +import type { + ClearSessionSavedataRequest, + ClearSessionSavedataResponse, + DeleteSessionSavedataRequest, + GetSessionSavedataRequest, + NewClearSessionSavedataRequest, + UpdateSessionSavedataRequest, +} from "#app/@types/PokerogueSessionSavedataApi"; +import { PokerogueSessionSavedataApi } from "#app/plugins/api/pokerogue-session-savedata-api"; +import type { SessionSaveData } from "#app/system/game-data"; +import { getApiBaseUrl } from "#app/test/utils/testUtils"; +import { http, HttpResponse } from "msw"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const apiBase = getApiBaseUrl(); +const sessionSavedataApi = new PokerogueSessionSavedataApi(apiBase); +const { server } = global; + +afterEach(() => { + server.resetHandlers(); +}); + +describe("Pokerogue Session Savedata API", () => { + beforeEach(() => { + vi.spyOn(console, "warn"); + }); + + describe("Newclear", () => { + const params: NewClearSessionSavedataRequest = { + clientSessionId: "test-session-id", + slot: 3, + }; + + it("should return true on SUCCESS", async () => { + server.use(http.get(`${apiBase}/savedata/session/newclear`, () => HttpResponse.json(true))); + + const success = await sessionSavedataApi.newclear(params); + + expect(success).toBe(true); + }); + + it("should return false on FAILURE", async () => { + server.use(http.get(`${apiBase}/savedata/session/newclear`, () => HttpResponse.json(false))); + + const success = await sessionSavedataApi.newclear(params); + + expect(success).toBe(false); + }); + + it("should return false and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/savedata/session/newclear`, () => HttpResponse.error())); + + const success = await sessionSavedataApi.newclear(params); + + expect(success).toBe(false); + expect(console.warn).toHaveBeenCalledWith("Could not newclear session!", expect.any(Error)); + }); + }); + + describe("Get ", () => { + const params: GetSessionSavedataRequest = { + clientSessionId: "test-session-id", + slot: 3, + }; + + it("should return session-savedata string on SUCCESS", async () => { + server.use(http.get(`${apiBase}/savedata/session/get`, () => HttpResponse.text("TEST SESSION SAVEDATA"))); + + const savedata = await sessionSavedataApi.get(params); + + expect(savedata).toBe("TEST SESSION SAVEDATA"); + }); + + it("should return null and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/savedata/session/get`, () => HttpResponse.error())); + + const savedata = await sessionSavedataApi.get(params); + + expect(savedata).toBeNull(); + expect(console.warn).toHaveBeenCalledWith("Could not get session savedata!", expect.any(Error)); + }); + }); + + describe("Update", () => { + const params: UpdateSessionSavedataRequest = { + clientSessionId: "test-session-id", + slot: 3, + secretId: 9876543321, + trainerId: 123456789, + }; + + it("should return an empty string on SUCCESS", async () => { + server.use(http.post(`${apiBase}/savedata/session/update`, () => HttpResponse.text(null))); + + const error = await sessionSavedataApi.update(params, "UPDATED SESSION SAVEDATA"); + + expect(error).toBe(""); + }); + + it("should return an error string on FAILURE", async () => { + server.use(http.post(`${apiBase}/savedata/session/update`, () => HttpResponse.text("Failed to update!"))); + + const error = await sessionSavedataApi.update(params, "UPDATED SESSION SAVEDATA"); + + expect(error).toBe("Failed to update!"); + }); + + it("should return 'Unknown Error!' and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/savedata/session/update`, () => HttpResponse.error())); + + const error = await sessionSavedataApi.update(params, "UPDATED SESSION SAVEDATA"); + + expect(error).toBe("Unknown Error!"); + expect(console.warn).toHaveBeenCalledWith("Could not update session savedata!", expect.any(Error)); + }); + }); + + describe("Delete", () => { + const params: DeleteSessionSavedataRequest = { + clientSessionId: "test-session-id", + slot: 3, + }; + + it("should return null on SUCCESS", async () => { + server.use(http.get(`${apiBase}/savedata/session/delete`, () => HttpResponse.text(null))); + + const error = await sessionSavedataApi.delete(params); + + expect(error).toBeNull(); + }); + + it("should return an error string on FAILURE", async () => { + server.use( + http.get(`${apiBase}/savedata/session/delete`, () => new HttpResponse("Failed to delete!", { status: 400 })) + ); + + const error = await sessionSavedataApi.delete(params); + + expect(error).toBe("Failed to delete!"); + }); + + it("should return 'Unknown error' and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/savedata/session/delete`, () => HttpResponse.error())); + + const error = await sessionSavedataApi.delete(params); + + expect(error).toBe("Unknown error"); + expect(console.warn).toHaveBeenCalledWith("Could not delete session savedata!", expect.any(Error)); + }); + }); + + describe("Clear", () => { + const params: ClearSessionSavedataRequest = { + clientSessionId: "test-session-id", + slot: 3, + trainerId: 123456789, + }; + + it("should return sucess=true on SUCCESS", async () => { + server.use( + http.post(`${apiBase}/savedata/session/clear`, () => + HttpResponse.json({ + success: true, + }) + ) + ); + + const { success, error } = await sessionSavedataApi.clear(params, {} as SessionSaveData); + + expect(success).toBe(true); + expect(error).toBeUndefined(); + }); + + it("should return sucess=false & an error string on FAILURE", async () => { + server.use( + http.post(`${apiBase}/savedata/session/clear`, () => + HttpResponse.json({ + success: false, + error: "Failed to clear!", + }) + ) + ); + + const { success, error } = await sessionSavedataApi.clear(params, {} as SessionSaveData); + + expect(error).toBe("Failed to clear!"); + expect(success).toBe(false); + }); + + it("should return success=false & error='Unknown error' and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/savedata/session/clear`, () => HttpResponse.error())); + + const { success, error } = await sessionSavedataApi.clear(params, {} as SessionSaveData); + + expect(error).toBe("Unknown error"); + expect(success).toBe(false); + }); + }); +}); diff --git a/src/test/plugins/api/pokerogue-system-savedata-api.test.ts b/src/test/plugins/api/pokerogue-system-savedata-api.test.ts new file mode 100644 index 00000000000..af377762b77 --- /dev/null +++ b/src/test/plugins/api/pokerogue-system-savedata-api.test.ts @@ -0,0 +1,122 @@ +import type { + GetSystemSavedataRequest, + UpdateSystemSavedataRequest, + VerifySystemSavedataRequest, + VerifySystemSavedataResponse, +} from "#app/@types/PokerogueSystemSavedataApi"; +import { PokerogueSystemSavedataApi } from "#app/plugins/api/pokerogue-system-savedata-api"; +import type { SystemSaveData } from "#app/system/game-data"; +import { getApiBaseUrl } from "#app/test/utils/testUtils"; +import { http, HttpResponse } from "msw"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const apiBase = getApiBaseUrl(); +const systemSavedataApi = new PokerogueSystemSavedataApi(getApiBaseUrl()); +const { server } = global; + +afterEach(() => { + server.resetHandlers(); +}); + +describe("Pokerogue System Savedata API", () => { + beforeEach(() => { + vi.spyOn(console, "warn"); + }); + + describe("Get", () => { + const params: GetSystemSavedataRequest = { + clientSessionId: "test-session-id", + }; + + it("should return system-savedata string on SUCCESS", async () => { + server.use(http.get(`${apiBase}/savedata/system/get`, () => HttpResponse.text("TEST SYSTEM SAVEDATA"))); + + const savedata = await systemSavedataApi.get(params); + + expect(savedata).toBe("TEST SYSTEM SAVEDATA"); + }); + + it("should return null and report a warning on ERROR", async () => { + server.use(http.get(`${apiBase}/savedata/system/get`, () => HttpResponse.error())); + + const savedata = await systemSavedataApi.get(params); + + expect(savedata).toBeNull(); + expect(console.warn).toHaveBeenCalledWith("Could not get system savedata!", expect.any(Error)); + }); + }); + + describe("Verify", () => { + const params: VerifySystemSavedataRequest = { + clientSessionId: "test-session-id", + }; + + it("should return null on SUCCESS", async () => { + server.use( + http.get(`${apiBase}/savedata/system/verify`, () => + HttpResponse.json({ + systemData: { + trainerId: 123456789, + } as SystemSaveData, + valid: true, + }) + ) + ); + + const savedata = await systemSavedataApi.verify(params); + + expect(savedata).toBeNull(); + }); + + it("should return system-savedata and report a warning on FAILURE", async () => { + server.use( + http.get(`${apiBase}/savedata/system/verify`, () => + HttpResponse.json({ + systemData: { + trainerId: 123456789, + } as SystemSaveData, + valid: false, + }) + ) + ); + + const savedata = await systemSavedataApi.verify(params); + + expect(savedata?.trainerId).toBe(123456789); + expect(console.warn).toHaveBeenCalledWith("Invalid system savedata!"); + }); + }); + + describe("Update", () => { + const params: UpdateSystemSavedataRequest = { + clientSessionId: "test-session-id", + secretId: 9876543321, + trainerId: 123456789, + }; + + it("should return an empty string on SUCCESS", async () => { + server.use(http.post(`${apiBase}/savedata/system/update`, () => HttpResponse.text(null))); + + const error = await systemSavedataApi.update(params, "UPDATED SYSTEM SAVEDATA"); + + expect(error).toBe(""); + }); + + it("should return an error string on FAILURE", async () => { + server.use(http.post(`${apiBase}/savedata/system/update`, () => HttpResponse.text("Failed to update!"))); + + const error = await systemSavedataApi.update(params, "UPDATED SYSTEM SAVEDATA"); + + expect(error).toBe("Failed to update!"); + }); + + it("should return 'Unknown Error' and report a warning on ERROR", async () => { + server.use(http.post(`${apiBase}/savedata/system/update`, () => HttpResponse.error())); + + const error = await systemSavedataApi.update(params, "UPDATED SYSTEM SAVEDATA"); + + expect(error).toBe("Unknown Error"); + expect(console.warn).toHaveBeenCalledWith("Could not update system savedata!", expect.any(Error)); + }); + }); +}); diff --git a/src/test/reload.test.ts b/src/test/reload.test.ts index b15e9691ed6..3b29cadf8e7 100644 --- a/src/test/reload.test.ts +++ b/src/test/reload.test.ts @@ -1,4 +1,5 @@ import { GameModes } from "#app/game-mode"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; import OptionSelectUiHandler from "#app/ui/settings/option-select-ui-handler"; import { Mode } from "#app/ui/ui"; import { Biome } from "#enums/biome"; @@ -7,7 +8,7 @@ import { Moves } from "#enums/moves"; import { Species } from "#enums/species"; import GameManager from "#test/utils/gameManager"; import { MockClock } from "#test/utils/mocks/mockClock"; -import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; describe("Reload", () => { let phaserGame: Phaser.Game; @@ -25,6 +26,8 @@ describe("Reload", () => { beforeEach(() => { game = new GameManager(phaserGame); + vi.spyOn(pokerogueApi, "getGameTitleStats").mockResolvedValue({ battleCount: -1, playerCount: -1 }); + vi.spyOn(pokerogueApi.daily, "getSeed").mockResolvedValue("test-seed"); }); it("should not have RNG inconsistencies in a Classic run", async () => { @@ -110,8 +113,7 @@ describe("Reload", () => { }, 20000); it("should not have RNG inconsistencies at a Daily run double battle", async () => { - game.override - .battleType("double"); + game.override.battleType("double"); await game.dailyMode.startBattle(); const preReloadRngState = Phaser.Math.RND.state(); @@ -124,9 +126,7 @@ describe("Reload", () => { }, 20000); it("should not have RNG inconsistencies at a Daily run Gym Leader fight", async () => { - game.override - .battleType("single") - .startingWave(40); + game.override.battleType("single").startingWave(40); await game.dailyMode.startBattle(); const preReloadRngState = Phaser.Math.RND.state(); @@ -139,9 +139,7 @@ describe("Reload", () => { }, 20000); it("should not have RNG inconsistencies at a Daily run regular trainer fight", async () => { - game.override - .battleType("single") - .startingWave(45); + game.override.battleType("single").startingWave(45); await game.dailyMode.startBattle(); const preReloadRngState = Phaser.Math.RND.state(); @@ -154,9 +152,7 @@ describe("Reload", () => { }, 20000); it("should not have RNG inconsistencies at a Daily run wave 50 Boss fight", async () => { - game.override - .battleType("single") - .startingWave(50); + game.override.battleType("single").startingWave(50); await game.runToFinalBossEncounter([ Species.BULBASAUR ], GameModes.DAILY); const preReloadRngState = Phaser.Math.RND.state(); diff --git a/src/test/system/game_data.test.ts b/src/test/system/game_data.test.ts index fcb7e9067a3..1e349470302 100644 --- a/src/test/system/game_data.test.ts +++ b/src/test/system/game_data.test.ts @@ -1,36 +1,23 @@ import * as BattleScene from "#app/battle-scene"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; import { SessionSaveData } from "#app/system/game-data"; import { Abilities } from "#enums/abilities"; import { Moves } from "#enums/moves"; import GameManager from "#test/utils/gameManager"; -import { http, HttpResponse } from "msw"; -import { setupServer } from "msw/node"; import Phaser from "phaser"; -import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; import * as account from "../../account"; -const apiBase = import.meta.env.VITE_API_BASE_URL ?? "http://localhost:8001"; - -/** We need a custom server. For some reasons I can't extend the listeners of {@linkcode global.i18nServer} with {@linkcode global.i18nServer.use} */ -const server = setupServer(); - describe("System - Game Data", () => { let phaserGame: Phaser.Game; let game: GameManager; beforeAll(() => { - global.i18nServer.close(); - server.listen(); phaserGame = new Phaser.Game({ type: Phaser.HEADLESS, }); }); - afterAll(() => { - server.close(); - global.i18nServer.listen(); - }); - beforeEach(() => { game = new GameManager(phaserGame); game.override @@ -41,7 +28,6 @@ describe("System - Game Data", () => { }); afterEach(() => { - server.resetHandlers(); game.phaseInterceptor.restoreOg(); }); @@ -61,7 +47,7 @@ describe("System - Game Data", () => { }); it("should return [true, true] if successful", async () => { - server.use(http.post(`${apiBase}/savedata/session/clear`, () => HttpResponse.json({ success: true }))); + vi.spyOn(pokerogueApi.savedata.session, "clear").mockResolvedValue({ success: true }); const result = await game.scene.gameData.tryClearSession(game.scene, 0); @@ -70,7 +56,7 @@ describe("System - Game Data", () => { }); it("should return [true, false] if not successful", async () => { - server.use(http.post(`${apiBase}/savedata/session/clear`, () => HttpResponse.json({ success: false }))); + vi.spyOn(pokerogueApi.savedata.session, "clear").mockResolvedValue({ success: false }); const result = await game.scene.gameData.tryClearSession(game.scene, 0); @@ -79,9 +65,7 @@ describe("System - Game Data", () => { }); it("should return [false, false] session is out of date", async () => { - server.use( - http.post(`${apiBase}/savedata/session/clear`, () => HttpResponse.json({ error: "session out of date" })) - ); + vi.spyOn(pokerogueApi.savedata.session, "clear").mockResolvedValue({ error: "session out of date" }); const result = await game.scene.gameData.tryClearSession(game.scene, 0); diff --git a/src/test/utils/gameWrapper.ts b/src/test/utils/gameWrapper.ts index 22517502a05..ca5a67f901a 100644 --- a/src/test/utils/gameWrapper.ts +++ b/src/test/utils/gameWrapper.ts @@ -79,7 +79,7 @@ export default class GameWrapper { constructor(phaserGame: Phaser.Game, bypassLogin: boolean) { Phaser.Math.RND.sow([ 'test' ]); - vi.spyOn(Utils, "apiFetch", "get").mockReturnValue(fetch); + // vi.spyOn(Utils, "apiFetch", "get").mockReturnValue(fetch); if (bypassLogin) { vi.spyOn(battleScene, "bypassLogin", "get").mockReturnValue(true); } diff --git a/src/test/utils/testUtils.ts b/src/test/utils/testUtils.ts index b922fc9c61c..a8410f8ba40 100644 --- a/src/test/utils/testUtils.ts +++ b/src/test/utils/testUtils.ts @@ -21,3 +21,11 @@ export function mockI18next() { export function arrayOfRange(start: integer, end: integer) { return Array.from({ length: end - start }, (_v, k) => k + start); } + +/** + * Utility to get the API base URL from the environment variable (or the default/fallback). + * @returns the API base URL + */ +export function getApiBaseUrl() { + return import.meta.env.VITE_SERVER_URL ?? "http://localhost:8001"; +} diff --git a/src/test/vitest.setup.ts b/src/test/vitest.setup.ts index 8438f607db2..0b83d112522 100644 --- a/src/test/vitest.setup.ts +++ b/src/test/vitest.setup.ts @@ -38,7 +38,7 @@ vi.mock("i18next", async (importOriginal) => { const { setupServer } = await import("msw/node"); const { http, HttpResponse } = await import("msw"); - global.i18nServer = setupServer( + global.server = setupServer( http.get("/locales/en/*", async (req) => { const filename = req.params[0]; @@ -50,9 +50,12 @@ vi.mock("i18next", async (importOriginal) => { console.log(`Failed to load locale ${filename}!`, err); return HttpResponse.json({}); } - }) + }), + http.get("https://fonts.googleapis.com/*", () => { + return HttpResponse.text(""); + }), ); - global.i18nServer.listen({ onUnhandledRequest: "error" }); + global.server.listen({ onUnhandledRequest: "error" }); console.log("i18n MSW server listening!"); return await importOriginal(); @@ -83,6 +86,6 @@ beforeAll(() => { }); afterAll(() => { - global.i18nServer.close(); + global.server.close(); console.log("Closing i18n MSW server!"); }); diff --git a/src/ui/admin-ui-handler.ts b/src/ui/admin-ui-handler.ts index 6249e54d8c3..269b5ac5096 100644 --- a/src/ui/admin-ui-handler.ts +++ b/src/ui/admin-ui-handler.ts @@ -1,10 +1,14 @@ import BattleScene from "#app/battle-scene"; -import { ModalConfig } from "./modal-ui-handler"; -import { Mode } from "./ui"; -import * as Utils from "../utils"; -import { FormModalUiHandler, InputFieldConfig } from "./form-modal-ui-handler"; import { Button } from "#app/enums/buttons"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; +import { formatText } from "#app/utils"; +import { FormModalUiHandler, InputFieldConfig } from "./form-modal-ui-handler"; +import { ModalConfig } from "./modal-ui-handler"; import { TextStyle } from "./text"; +import { Mode } from "./ui"; + +type AdminUiHandlerService = "discord" | "google"; +type AdminUiHandlerServiceMode = "Link" | "Unlink"; export default class AdminUiHandler extends FormModalUiHandler { @@ -17,17 +21,15 @@ export default class AdminUiHandler extends FormModalUiHandler { private readonly httpUserNotFoundErrorCode: number = 404; private readonly ERR_REQUIRED_FIELD = (field: string) => { if (field === "username") { - return `${Utils.formatText(field)} is required`; + return `${formatText(field)} is required`; } else { - return `${Utils.formatText(field)} Id is required`; + return `${formatText(field)} Id is required`; } }; // returns a string saying whether a username has been successfully linked/unlinked to discord/google private readonly SUCCESS_SERVICE_MODE = (service: string, mode: string) => { return `Username and ${service} successfully ${mode.toLowerCase()}ed`; }; - private readonly ERR_USERNAME_NOT_FOUND: string = "Username not found!"; - private readonly ERR_GENERIC_ERROR: string = "There was an error"; constructor(scene: BattleScene, mode: Mode | null = null) { super(scene, mode); @@ -148,7 +150,6 @@ export default class AdminUiHandler extends FormModalUiHandler { } else if (this.adminMode === AdminMode.ADMIN) { this.updateAdminPanelInfo(adminSearchResult, AdminMode.SEARCH); } - return false; }; return true; } @@ -196,7 +197,7 @@ export default class AdminUiHandler extends FormModalUiHandler { this.scene.ui.setMode(Mode.LOADING, { buttonActions: []}); // this is here to force a loading screen to allow the admin tool to reopen again if there's an error return this.showMessage(validFields.errorMessage ?? "", adminResult, true); } - this.adminLinkUnlink(this.convertInputsToAdmin(), service, mode).then(response => { // attempts to link/unlink depending on the service + this.adminLinkUnlink(this.convertInputsToAdmin(), service as AdminUiHandlerService, mode).then(response => { // attempts to link/unlink depending on the service if (response.error) { this.scene.ui.setMode(Mode.LOADING, { buttonActions: []}); return this.showMessage(response.errorType, adminResult, true); // fail @@ -276,12 +277,11 @@ export default class AdminUiHandler extends FormModalUiHandler { private async adminSearch(adminSearchResult: AdminSearchInfo) { try { - const adminInfo = await Utils.apiFetch(`admin/account/adminSearch?username=${encodeURIComponent(adminSearchResult.username)}`, true); - if (!adminInfo.ok) { // error - if adminInfo.status === this.httpUserNotFoundErrorCode that means the username can't be found in the db - return { adminSearchResult: adminSearchResult, error: true, errorType: adminInfo.status === this.httpUserNotFoundErrorCode ? this.ERR_USERNAME_NOT_FOUND : this.ERR_GENERIC_ERROR }; + const [ adminInfo, errorType ] = await pokerogueApi.admin.searchAccount({ username: adminSearchResult.username }); + if (errorType || !adminInfo) { // error - if adminInfo.status === this.httpUserNotFoundErrorCode that means the username can't be found in the db + return { adminSearchResult: adminSearchResult, error: true, errorType }; } else { // success - const adminInfoJson: AdminSearchInfo = await adminInfo.json(); - return { adminSearchResult: adminInfoJson, error: false }; + return { adminSearchResult: adminInfo, error: false }; } } catch (err) { console.error(err); @@ -289,12 +289,47 @@ export default class AdminUiHandler extends FormModalUiHandler { } } - private async adminLinkUnlink(adminSearchResult: AdminSearchInfo, service: string, mode: string) { + private async adminLinkUnlink(adminSearchResult: AdminSearchInfo, service: AdminUiHandlerService, mode: AdminUiHandlerServiceMode) { try { - const response = await Utils.apiPost(`admin/account/${service}${mode}`, `username=${encodeURIComponent(adminSearchResult.username)}&${service}Id=${encodeURIComponent(service === "discord" ? adminSearchResult.discordId : adminSearchResult.googleId)}`, "application/x-www-form-urlencoded", true); - if (!response.ok) { // error - if response.status === this.httpUserNotFoundErrorCode that means the username can't be found in the db - return { adminSearchResult: adminSearchResult, error: true, errorType: response.status === this.httpUserNotFoundErrorCode ? this.ERR_USERNAME_NOT_FOUND : this.ERR_GENERIC_ERROR }; - } else { // success! + let errorType: string | null = null; + + if (service === "discord") { + if (mode === "Link") { + errorType = await pokerogueApi.admin.linkAccountToDiscord({ + discordId: adminSearchResult.discordId, + username: adminSearchResult.username, + }); + } else if (mode === "Unlink") { + errorType = await pokerogueApi.admin.unlinkAccountFromDiscord({ + discordId: adminSearchResult.discordId, + username: adminSearchResult.username, + }); + } else { + console.warn("Unknown mode", mode, "for service", service); + } + } else if (service === "google") { + if (mode === "Link") { + errorType = await pokerogueApi.admin.linkAccountToGoogleId({ + googleId: adminSearchResult.googleId, + username: adminSearchResult.username, + }); + } else if (mode === "Unlink") { + errorType = await pokerogueApi.admin.unlinkAccountFromGoogleId({ + googleId: adminSearchResult.googleId, + username: adminSearchResult.username, + }); + } else { + console.warn("Unknown mode", mode, "for service", service); + } + } else { + console.warn("Unknown service", service); + } + + if (errorType) { + // error - if response.status === this.httpUserNotFoundErrorCode that means the username can't be found in the db + return { adminSearchResult: adminSearchResult, error: true, errorType }; + } else { + // success! return { adminSearchResult: adminSearchResult, error: false }; } } catch (err) { diff --git a/src/ui/daily-run-scoreboard.ts b/src/ui/daily-run-scoreboard.ts index b9c1c6ea49a..bb93b1fb1f5 100644 --- a/src/ui/daily-run-scoreboard.ts +++ b/src/ui/daily-run-scoreboard.ts @@ -3,8 +3,9 @@ import BattleScene from "../battle-scene"; import * as Utils from "../utils"; import { TextStyle, addTextObject } from "./text"; import { WindowVariant, addWindow } from "./ui-theme"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; -interface RankingEntry { +export interface RankingEntry { rank: integer, username: string, score: integer, @@ -12,7 +13,7 @@ interface RankingEntry { } // Don't forget to update translations when adding a new category -enum ScoreboardCategory { +export enum ScoreboardCategory { DAILY, WEEKLY } @@ -191,18 +192,17 @@ export class DailyRunScoreboard extends Phaser.GameObjects.Container { } Utils.executeIf(category !== this.category || this.pageCount === undefined, - () => Utils.apiFetch(`daily/rankingpagecount?category=${category}`).then(response => response.json()).then(count => this.pageCount = count) + () => pokerogueApi.daily.getRankingsPageCount({ category }).then(count => this.pageCount = count) ).then(() => { - Utils.apiFetch(`daily/rankings?category=${category}&page=${page}`) - .then(response => response.json()) - .then(jsonResponse => { + pokerogueApi.daily.getRankings({ category, page }) + .then(rankings => { this.page = page; this.category = category; this.titleLabel.setText(`${i18next.t(`menu:${ScoreboardCategory[category].toLowerCase()}Rankings`)}`); this.pageNumberLabel.setText(page.toString()); - if (jsonResponse) { + if (rankings) { this.loadingLabel.setVisible(false); - this.updateRankings(jsonResponse); + this.updateRankings(rankings); } else { this.loadingLabel.setText(i18next.t("menu:noRankings")); } diff --git a/src/ui/login-form-ui-handler.ts b/src/ui/login-form-ui-handler.ts index 26a2a225ec6..bba900aef0a 100644 --- a/src/ui/login-form-ui-handler.ts +++ b/src/ui/login-form-ui-handler.ts @@ -7,6 +7,7 @@ import BattleScene from "#app/battle-scene"; import { addTextObject, TextStyle } from "./text"; import { addWindow } from "./ui-theme"; import { OptionSelectItem } from "#app/ui/abstact-option-select-ui-handler"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; interface BuildInteractableImageOpts { scale?: number; @@ -135,21 +136,16 @@ export default class LoginFormUiHandler extends FormModalUiHandler { if (!this.inputs[0].text) { return onFail(i18next.t("menu:emptyUsername")); } - Utils.apiPost("account/login", `username=${encodeURIComponent(this.inputs[0].text)}&password=${encodeURIComponent(this.inputs[1].text)}`, "application/x-www-form-urlencoded") - .then(response => { - if (!response.ok) { - return response.text(); - } - return response.json(); - }) - .then(response => { - if (response.hasOwnProperty("token")) { - Utils.setCookie(Utils.sessionIdKey, response.token); - originalLoginAction && originalLoginAction(); - } else { - onFail(response); - } - }); + + const [ usernameInput, passwordInput ] = this.inputs; + + pokerogueApi.account.login({ username: usernameInput.text, password: passwordInput.text }).then(error => { + if (!error) { + originalLoginAction && originalLoginAction(); + } else { + onFail(error); + } + }); }; return true; diff --git a/src/ui/menu-ui-handler.ts b/src/ui/menu-ui-handler.ts index fea0a70af91..3ce3f3b7cf0 100644 --- a/src/ui/menu-ui-handler.ts +++ b/src/ui/menu-ui-handler.ts @@ -14,6 +14,7 @@ import BgmBar from "#app/ui/bgm-bar"; import AwaitableUiHandler from "./awaitable-ui-handler"; import { SelectModifierPhase } from "#app/phases/select-modifier-phase"; import { AdminMode, getAdminModeName } from "./admin-ui-handler"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; enum MenuOptions { GAME_SETTINGS, @@ -539,10 +540,7 @@ export default class MenuUiHandler extends MessageUiHandler { window.open(discordUrl, "_self"); return true; } else { - Utils.apiPost("/auth/discord/logout", undefined, undefined, true).then(res => { - if (!res.ok) { - console.error(`Unlink failed (${res.status}: ${res.statusText})`); - } + pokerogueApi.unlinkDiscord().then(_isSuccess => { updateUserInfo().then(() => this.scene.reset(true, true)); }); return true; @@ -560,10 +558,7 @@ export default class MenuUiHandler extends MessageUiHandler { window.open(googleUrl, "_self"); return true; } else { - Utils.apiPost("/auth/google/logout", undefined, undefined, true).then(res => { - if (!res.ok) { - console.error(`Unlink failed (${res.status}: ${res.statusText})`); - } + pokerogueApi.unlinkGoogle().then(_isSuccess => { updateUserInfo().then(() => this.scene.reset(true, true)); }); return true; @@ -612,11 +607,7 @@ export default class MenuUiHandler extends MessageUiHandler { success = true; const doLogout = () => { ui.setMode(Mode.LOADING, { - buttonActions: [], fadeOut: () => Utils.apiFetch("account/logout", true).then(res => { - if (!res.ok) { - console.error(`Log out failed (${res.status}: ${res.statusText})`); - } - Utils.removeCookie(Utils.sessionIdKey); + buttonActions: [], fadeOut: () => pokerogueApi.account.logout().then(() => { updateUserInfo().then(() => this.scene.reset(true, true)); }) }); diff --git a/src/ui/registration-form-ui-handler.ts b/src/ui/registration-form-ui-handler.ts index 2c35ff8ee7f..892f78bd1ba 100644 --- a/src/ui/registration-form-ui-handler.ts +++ b/src/ui/registration-form-ui-handler.ts @@ -1,9 +1,9 @@ import { FormModalUiHandler, InputFieldConfig } from "./form-modal-ui-handler"; import { ModalConfig } from "./modal-ui-handler"; -import * as Utils from "../utils"; import { Mode } from "./ui"; import { TextStyle, addTextObject } from "./text"; import i18next from "i18next"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; interface LanguageSetting { @@ -110,27 +110,20 @@ export default class RegistrationFormUiHandler extends FormModalUiHandler { if (this.inputs[1].text !== this.inputs[2].text) { return onFail(i18next.t("menu:passwordNotMatchingConfirmPassword")); } - Utils.apiPost("account/register", `username=${encodeURIComponent(this.inputs[0].text)}&password=${encodeURIComponent(this.inputs[1].text)}`, "application/x-www-form-urlencoded") - .then(response => response.text()) - .then(response => { - if (!response) { - Utils.apiPost("account/login", `username=${encodeURIComponent(this.inputs[0].text)}&password=${encodeURIComponent(this.inputs[1].text)}`, "application/x-www-form-urlencoded") - .then(response => { - if (!response.ok) { - return response.text(); - } - return response.json(); - }) - .then(response => { - if (response.hasOwnProperty("token")) { - Utils.setCookie(Utils.sessionIdKey, response.token); + const [ usernameInput, passwordInput ] = this.inputs; + pokerogueApi.account.register({ username: usernameInput.text, password: passwordInput.text }) + .then(registerError => { + if (!registerError) { + pokerogueApi.account.login({ username: usernameInput.text, password: passwordInput.text }) + .then(loginError => { + if (!loginError) { originalRegistrationAction && originalRegistrationAction(); } else { - onFail(response); + onFail(loginError); } }); } else { - onFail(response); + onFail(registerError); } }); }; diff --git a/src/ui/title-ui-handler.ts b/src/ui/title-ui-handler.ts index 3bfba71ef08..aec80f049c9 100644 --- a/src/ui/title-ui-handler.ts +++ b/src/ui/title-ui-handler.ts @@ -7,6 +7,7 @@ import { getSplashMessages } from "../data/splash-messages"; import i18next from "i18next"; import { TimedEventDisplay } from "#app/timed-event-manager"; import { version } from "../../package.json"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; export default class TitleUiHandler extends OptionSelectUiHandler { /** If the stats can not be retrieved, use this fallback value */ @@ -78,12 +79,13 @@ export default class TitleUiHandler extends OptionSelectUiHandler { } updateTitleStats(): void { - Utils.apiFetch("game/titlestats") - .then(request => request.json()) + pokerogueApi.getGameTitleStats() .then(stats => { - this.playerCountLabel.setText(`${stats.playerCount} ${i18next.t("menu:playersOnline")}`); - if (this.splashMessage === "splashMessages:battlesWon") { - this.splashMessageText.setText(i18next.t(this.splashMessage, { count: stats.battleCount })); + if (stats) { + this.playerCountLabel.setText(`${stats.playerCount} ${i18next.t("menu:playersOnline")}`); + if (this.splashMessage === "splashMessages:battlesWon") { + this.splashMessageText.setText(i18next.t(this.splashMessage, { count: stats.battleCount })); + } } }) .catch(err => { diff --git a/src/utils.ts b/src/utils.ts index 8b779f32730..be0aec84ecd 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -1,6 +1,7 @@ import { MoneyFormat } from "#enums/money-format"; import { Moves } from "#enums/moves"; import i18next from "i18next"; +import { pokerogueApi } from "#app/plugins/api/pokerogue-api"; export type nil = null | undefined; @@ -258,9 +259,16 @@ export const isLocal = ( /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/.test(window.location.hostname)) && window.location.port !== "") || window.location.hostname === ""; +/** + * @deprecated Refer to [pokerogue-api.ts](./plugins/api/pokerogue-api.ts) instead + */ export const localServerUrl = import.meta.env.VITE_SERVER_URL ?? `http://${window.location.hostname}:${window.location.port + 1}`; -// Set the server URL based on whether it's local or not +/** + * Set the server URL based on whether it's local or not + * + * @deprecated Refer to [pokerogue-api.ts](./plugins/api/pokerogue-api.ts) instead + */ export const apiUrl = localServerUrl ?? "https://api.pokerogue.net"; // used to disable api calls when isLocal is true and a server is not found export let isLocalServerConnected = true; @@ -307,48 +315,14 @@ export function getCookie(cName: string): string { * with a GET request to verify if a server is running, * sets isLocalServerConnected based on results */ -export function localPing() { +export async function localPing() { if (isLocal) { - apiFetch("game/titlestats") - .then(resolved => isLocalServerConnected = true, - rejected => isLocalServerConnected = false - ); + const titleStats = await pokerogueApi.getGameTitleStats(); + isLocalServerConnected = !!titleStats; + console.log("isLocalServerConnected:", isLocalServerConnected); } } -export function apiFetch(path: string, authed: boolean = false): Promise { - return (isLocal && isLocalServerConnected) || !isLocal ? new Promise((resolve, reject) => { - const request = {}; - if (authed) { - const sId = getCookie(sessionIdKey); - if (sId) { - request["headers"] = { "Authorization": sId }; - } - } - fetch(`${apiUrl}/${path}`, request) - .then(response => resolve(response)) - .catch(err => reject(err)); - }) : new Promise(() => {}); -} - -export function apiPost(path: string, data?: any, contentType: string = "application/json", authed: boolean = false): Promise { - return (isLocal && isLocalServerConnected) || !isLocal ? new Promise((resolve, reject) => { - const headers = { - "Accept": contentType, - "Content-Type": contentType, - }; - if (authed) { - const sId = getCookie(sessionIdKey); - if (sId) { - headers["Authorization"] = sId; - } - } - fetch(`${apiUrl}/${path}`, { method: "POST", headers: headers, body: data }) - .then(response => resolve(response)) - .catch(err => reject(err)); - }) : new Promise(() => {}); -} - /** Alias for the constructor of a class */ export type Constructor = new(...args: unknown[]) => T;