db_manipulation_testing

Create data-driven QA tests by mutating in-memory game databases.

1|Updated Feb 21, 2026
One-click install
npx skills add https://github.com/trioskosmos/rabukasim --skill db-manipulation-testing
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: db_manipulation_testing
Source: https://github.com/trioskosmos/rabukasim/tree/main/.agent/skills/db_manipulation_testing
Command: npx skills add https://github.com/trioskosmos/rabukasim --skill db-manipulation-testing

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill enables the creation of highly specific QA tests by allowing dynamic manipulation of the game's database in memory, which is crucial for testing complex rules and edge cases.

Core Features & Use Cases

  • In-Memory Database Mutation: Load the cards_compiled.json, convert it to a CardDatabase, and modify abilities or card data directly in memory before game state simulation.
  • Targeted Ability Testing: Overwrite card ability bytecode to isolate and test specific mechanics without needing to satisfy complex in-game conditions.
  • Direct Interpreter Calls: Unit test individual opcodes and bytecode logic by calling the interpreter directly.
  • Full Event Pipeline Testing: Simulate end-to-end gameplay by enqueuing abilities and stepping through the game loop to test suspensions and responses.

Quick Start

Use the db_manipulation_testing skill to create a new test file in engine_rust_src/tests/ named repro_example_test.rs that manipulates card abilities in memory.

Frequently Asked Questions about db_manipulation_testing

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I test game logic by modifying the game database in memory?

To test game logic via database manipulation, load the `cards_compiled.json` file, convert it to a `CardDatabase`, and modify abilities or card data directly in memory before simulating the game state. This allows you to isolate and test specific mechanics easily.

How do I test specific card abilities without triggering in-game conditions?

You can test specific card abilities without triggering in-game conditions by overwriting the card ability bytecode directly in the in-memory database. This isolates the mechanics, bypassing complex prerequisites and focusing on the targeted rule or edge case.

What is the best way to unit test individual opcodes and bytecode logic?

The best way to unit test individual opcodes and bytecode logic is by calling the interpreter directly. This approach allows for deterministic testing of specific game engine components without running the full event pipeline.

Can I simulate end-to-end gameplay to test game engine suspensions and responses?

Yes, you can simulate end-to-end gameplay to test suspensions and responses by enqueuing abilities and stepping through the game loop. This full event pipeline testing ensures all game engine components interact correctly.

Does database manipulation testing work for testing broken mechanics and edge cases?

Database manipulation testing works effectively for testing broken mechanics and edge cases. By dynamically overwriting card abilities and bytecode in memory, you can reproduce specific scenarios and verify complex rules deterministically.

Do I need to create a new test file in a specific directory for database manipulation testing?

Yes, you need to create a new test file in the `engine_rust_src/tests/` directory, such as `repro_example_test.rs`. This is where you define your data-driven QA verification tests by manipulating card abilities in memory.