Test tooling

When you wire Kraty into your game you need to exercise behaviour that normally only happens on a schedule: a window ending, a weekly board rolling over, bots filling a lobby, rewards and webhooks firing. Waiting for the real clock is no way to test. The Test tooling lets you trigger those paths on demand.

Two ways to drive it

Both hit the same underlying engine; they differ only in who's allowed to fire them and how.

The event Test tab

Open an event and switch to Test. Actions resolve the event's current test window:

• End the window now: finalize the active test window exactly as the scheduler would at endsAt: settle leaderboards, expire in-progress attempts, dispatch window-end rewards and webhooks, close lobbies.
• Reopen the window: re-activate an ended test window so you can keep playing. Its leaderboards are un-finalized (entries cleared back to live) and lobbies reopened. Lets you replay an end-of-window without recreating the event.
• Start a new instance: close the current test window and open a fresh one right now, with new leaderboards and bot fills — like the next scheduled occurrence, without the wait. It ends when the current scheduled occurrence would have: on a Sunday-to-Sunday weekly event, starting one on a Friday gives you a two-day instance that finishes on Sunday and hands back to the normal schedule. (It does not restart the full duration, so repeated use can't drift the event off its calendar.) Between occurrences it runs until the next one opens.
• Inject test players: add N synthetic ranked players to the active test board, so you can see a populated leaderboard immediately.
• Bots: draw bots onto the test board. Pick a bot type to use a specific bot, or leave it on Event's bot bindings to draw from what the event is configured with. Remove bots clears them again.
• Clear the board: wipe the active test window's leaderboard.
• Teams (team events): Inject creates sim players in teams through the real pipeline (rosters of Per team players on studio-roster events, matching, partner pairs, or a country from the tier field), then scores them through attempt progress. The Teams card adds Set a roster (studio-roster events), Contribute as a member (a random member, everyone, or one member, through the real progress path, so milestones, boards and payouts fire), Recompute (rebuild a team's score and board row) and Retry payout (a team whose payout failed).
• Open test lobbies: each forming/active test lobby is listed with:
  • Fill (forming only): promote the lobby now and top up empty seats with bots, the same path matchmaking takes on a fill-by timeout.
  • Close: close the lobby.

The leaderboard Test tab

Open a leaderboard and switch to Test:

• Roll over the period now: snapshot the current period, pay per-place / per-progression-tier rewards, apply promotion & relegation, and open a fresh period. A no-op on an all-time board.
• Inject test players: seed synthetic ranked players. On a segmented board you pass the tier / segment value to seed.
• Clear the test board: wipe every test ranking across all segments.

Reading a segmented event's standings

On a team event the Standings tab opens on Teams: the team board (rows open a team), and a card per team with its score, goal bar (boss HP on a raid) and milestones. Pick a team to see its members by contribution, which milestones each member was paid (or is waiting on), partner checkpoints and the payout state. It refreshes while the current window runs. Players switches back to the player boards.

On the event's Standings tab, the Tier / segment picker switches divisions. When a division is capped at N players it splits into several cohorts — separate boards that share the same division — and a Cohort picker appears next to it, labelled with each cohort's player count (Cohort 2 · 18/30 players). Without it you'd only ever see the first cohort, so a player sitting in the second one looks missing from standings.

Play it as a player: the SDK playground

The playground is a game client in your browser. It plays your game through the same TypeScript SDK your game ships with, so you can try an integration before your own build has UI for it, or demo it to your team. Create players and set their level and trophies, join your events and race the bots on a live board, submit leaderboard scores, report pretend purchases and open rewards. Every SDK call and its response shows in a request log.

• Level and Trophies on the player card are the player's real server values (your level / trophies progression items), the ones guild gates and events read; − / + move them. They push progress with wallet.progress like a game would (a level computed from XP moves by pushing the XP that level needs). In the dashboard playground, items your game doesn't let clients write go through the dashboard's own audited player adjust instead, and Top up adds currencies (a guild's founding cost). The Demo App playground is SDK-only: an item it can't write shows a locked stepper with the reason. Without such an item, the steppers set only the context sent on event joins.
• Guilds tab (when guilds are on for test players): your minimum to create or join, if you set one, as one line; recommended guilds (10, with shuffle) or a name search (20 at a time, Load more) as compact rows (members out of 50, open or request-to-join, points this week); a guild's roster in a side panel; Found a guild in a dialog. Inside a guild: members with the tools your role holds (promote, demote, kick, hand over), the request inbox, help requests (ask and donate), editing, leaving, and the weekly guild board. Switch player to play the other side.

Open it from your game's sidebar: Playground (or Open playground on the API keys page). There's no key to create or paste: the playground issues itself a test Client SDK key that lasts 24 hours and doesn't show in your API keys list. It's available to the same roles as the Test tabs.

Team events play too: a team event's tile has a Team button that opens its setup (put players in teams as your server would, find a team, invite a partner and accept as them, or pick a country), and the match screen shows your team's score, goal, milestones and members, with +10 buttons that score as a teammate so you can watch the team move.

Players you create in the playground are ordinary test players, so they show up in the dashboard like any other. They're kept in your browser, and open tabs share them, so you can run one tab per player to race them against each other.

Guild test tools

Guild rules that take days (a 30-day inactive leader) or many players (the 50-member cap) have test tools on the dashboard API, for test guilds only (dev_tools.trigger; GAME_QA included):

POST /admin/v1/studios/{studioId}/games/{gameId}/dev/guilds/{guildId}/fill                          { "count": 49 }
POST /admin/v1/studios/{studioId}/games/{gameId}/dev/guilds/{guildId}/members/{externalPlayerId}/idle { "days": 31 }
POST /admin/v1/studios/{studioId}/games/{gameId}/dev/guilds/sweep-leaders

fill adds generated test players as members (through the normal path: count, cap and webhooks). idle makes a member look away for that many days. sweep-leaders runs the inactive-leader hand-over now instead of on the hourly worker tick. See Guilds.

Dev endpoints (for automated tests)

For CI and integration tests, the same force-end and force-rollover live on the server API, driven by a test server_integration key:

POST /server/v1/dev/events/{eventKey}/end-now
POST /server/v1/dev/leaderboards/{leaderboardKey}/rollover-now

Both resolve the event / board by its stable key within the calling key's game, and act on that key's environment.

To wipe accumulated test data and start from a clean slate, use Reset test data in Game settings.