OpenParable
Skip to content
← Back to skills

Dust Test

Testing & Quality
dust-test

Dust Test is an Agent Skill for testing & quality published in the dust-tt/dust repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Step-by-step guide for writing focused, practical tests for Dust codebases following the 80/20 principle.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/dust-tt/dust/blob/HEAD/.claude/skills/dust-test/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/dust-test, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Creating automated tests for Dust codebases

Write focused, practical tests for the current file following the 80/20 principle.

Instructions

When writing tests for a file:

  1. Identify the core functionality: Focus on the most important paths and edge cases that provide 80% of the value
  2. Keep it simple: Write straightforward tests that are easy to understand and maintain
  3. Minimal mocking:
    • DO NOT mock the database
    • Only mock external services (APIs, third-party services)
    • Prefer real implementations when possible
  4. Use factories: Leverage test factories to set up data efficiently
  5. Focus on behavior: Test what the code does, not how it does it

For Front (TypeScript/Next.js)

Setup

  • Import factories from front/tests/utils/factories
  • Import utilities from front/tests/utils/utils
  • Use the test database (no mocking)

Structure

import {describe, it, expect} from "vitest";
import {makeTestWorkspace, makeTestUser} from "tests/utils/factories";

describe ("ComponentName or FunctionName", () => {
    it ("should handle the main happy path", async () => {
        // Arrange: Set up using factories
        const {workspace} = createResourceTest ()

        // Act: Execute the code
        const result = await functionUnderTest (workspace);

        // Assert: Verify behavior
        expect (result).toBeDefined ();
    });

    it ("should handle the most common edge case", async () => {
        // Test the second most important scenario
    });
});

What to test (80/20 focus)

  • Main success paths
  • Most common error conditions
  • Critical edge cases (null/undefined, empty arrays, etc.)
  • Permission checks (if applicable)

What to skip (diminishing returns)

  • Exhaustive parameter combinations
  • Unlikely edge cases
  • Internal implementation details
  • UI component rendering (unless critical)

For Connectors/Core

Follow similar principles:

  • Use factories appropriate to the service
  • Focus on integration points
  • Mock external APIs only (Slack, Notion, GitHub, etc.)
  • Test the database interactions directly

Example Pattern

describe ("createConversation", () => {
    it ("creates conversation with valid params", async () => {
        const {workspace, user} = createResourceTest ()
   
        const conversation = await createConversation ({
            workspace,
            userId: user.id,
            title: "Test"
        });
   
        expect (conversation.sId).toBeDefined ();
        expect (conversation.title).toBe ("Test");
    });
   
    it ("fails without required permissions", async () => {
        const {workspace, user} = createResourceTest ()
   
        await expect (
            createConversation ({workspace, userId: user.id})
        ).rejects.toThrow ("Permission denied");
    });
});

Execution Steps

  1. Read the file to understand its purpose and main exports
  2. Check if a test file already exists (e.g., file.test.ts)
  3. Identify the 2-4 most important functions/behaviors to test
  4. Find or create appropriate factories for test data
  5. Write concise, focused tests
  6. Run tests with npm test -- filetotest to verify they pass