Run Your First Discovery

What is System Discovery?

System Discovery is an AI-powered analysis process that examines your application's documentation, API specifications, and user stories to identify testable components. It automatically extracts:

• API Methods - REST endpoints, GraphQL queries, and mutations
• UI Pages - Web pages and user interface screens
• Entities - Data models and business objects
• User Flows - Common user journeys and workflows
• User Stories - Jira tickets and acceptance criteria

Why Run Discovery?

Discovery provides several key benefits:

• Automated Test Planning - Identifies what needs to be tested without manual analysis
• Comprehensive Coverage - Ensures no critical functionality is overlooked
• Context for AI - Gives the test generation engine deep understanding of your application
• Living Documentation - Maintains an up-to-date map of your application structure

Step 1: Navigate to Discovery

From your project workspace, click Discovery in the left sidebar. You'll see the System Discovery page with sections for Knowledge Sources, Environment selection, and Discovery Results.

Step 2: Add a Knowledge Source

Knowledge sources are the inputs that discovery analyzes to understand your application. Click the"+ Add Source" button and choose one of these options:

Option A: Upload Documentation Files

Upload technical documentation, user guides, or specification documents about your application.

• Supported formats: PDF, Markdown (.md), Text (.txt), Word (.docx)
• What to upload: API documentation, feature specs, user guides, architecture docs
• Best practice: Upload comprehensive documentation that describes functionality and workflows

To add:

1. Select "Upload Documentation" as the source type
2. Enter a descriptive name (e.g., "API Documentation", "User Guide")
3. Click "Choose Files" or drag files into the upload area
4. Select your documentation files
5. Click "Add Source"

Option B: Connect API Specification

Connect an OpenAPI (Swagger) specification file or URL that describes your REST API.

• Supported formats: OpenAPI 2.0 (Swagger), OpenAPI 3.0+
• Input types: File upload or URL to hosted specification
• What it discovers: All API endpoints, request/response schemas, parameters

To add:

1. Select "API Specification" as the source type
2. Enter a name (e.g., "Backend API Spec")
3. Either:
   • Upload your OpenAPI JSON/YAML file, OR
   • Enter the URL where your API spec is hosted
4. Click "Add Source"

Option C: Connect Jira

Link your Jira project to import user stories and acceptance criteria as test scenarios.

• What it discovers: User stories, epics, tasks with descriptions and acceptance criteria
• Requirements: Jira project URL, authentication credentials or API token
• Best for: Behavior-driven testing aligned with product requirements

To add:

1. Select "Jira" as the source type
2. Enter your Jira instance URL
3. Provide authentication (API token recommended)
4. Select the Jira project to analyze
5. Click "Add Source"

Step 3: Select Your Environment

In the Environment section, select which environment should be used for discovery. The system will use this environment's configuration to access your application if needed (for example, to crawl UI pages or validate API endpoints).

Make sure the environment you select has:

• A valid Main UI URL (for UI discovery)
• Login credentials (if authentication is required)
• An API endpoint (for API discovery)

Step 4: Click "Re-run Discovery"

Once you have at least one knowledge source and an environment selected, click the"Re-run Discovery" button. This initiates the discovery process.

Note: The button says "Re-run" because you can run discovery multiple times as your application evolves or when you add new knowledge sources.

Step 5: Monitor Discovery Progress

Discovery runs in the background and typically takes a few minutes depending on the size of your knowledge sources. You'll see:

• A progress indicator showing the current phase
• Status updates as different sources are analyzed
• Real-time streaming of discovered artifacts

Discovery phases include:

1. Initialization - Setting up the analysis pipeline
2. Source Analysis - Processing documentation and specifications
3. Artifact Extraction - Identifying APIs, pages, and entities
4. Relationship Mapping - Understanding connections between components
5. Completion - Finalizing results

Step 6: Review Discovery Results

When discovery completes, you'll see the Discovery Results section with expandable categories:

Detected API Methods

Lists all REST API endpoints discovered from your API specification or documentation. Each entry shows:

• HTTP method (GET, POST, PUT, DELETE, etc.)
• Endpoint path (e.g., /api/users/:id)
• Description of what the endpoint does

Detected UI Pages

Shows web pages and screens identified in your documentation or crawled from your application. Each entry includes:

• Page URL or route
• Page title or description
• Key functionality available on that page

Example: https://www.example.com/login, https://portal.example.com/dashboard

Jira User Stories

If you connected Jira, this section displays user stories and their acceptance criteria. Each story can be used as a basis for generating functional tests.

Discovered Entities

Data models and business objects identified in your application, such as:

• User, Customer, Account
• Order, Product, Invoice
• Project, Task, Comment

Understanding entities helps generate tests that validate data operations (create, read, update, delete).

User Flows

Common workflows and multi-step processes discovered in your documentation:

• Login → Browse Products → Add to Cart → Checkout
• Register Account → Verify Email → Complete Profile
• Create Project → Add Team Members → Assign Tasks

User flows are ideal for generating end-to-end integration tests.

Re-running Discovery

You should re-run discovery when:

• You add new knowledge sources
• Your application's API or UI has changed significantly
• You update documentation or specifications
• You want to refresh the discovered artifacts

Re-running discovery won't affect your existing tests, but it will provide updated context for generating new tests.

What's Next?

Now that discovery has analyzed your application and identified testable components, you're ready to generate tests! The AI will use the discovered artifacts to create comprehensive test cases tailored to your application.

Continue to: Generate & Run Your First Test