Apidog Docs
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
Discord Community
Slack Community
X / Twitter
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
  1. Develop and Debug APIs
  • Apidog Learning Center
  • Getting Started
    • Introduction to Apidog
    • Basic Concepts in Apidog
    • Navigating Apidog
    • Quick Start
      • Overview
      • Creating an Endpoint
      • Making a Request
      • Adding an Assertion
      • Creating Test Scenarios
      • Sharing API Documentation
      • Explore More
    • Migration to Apidog
      • Overview
      • Manual Import
      • Scheduled Import (Bind Data Sources)
      • Import Options
      • Export Data
      • Import From
        • Import from Postman
        • Import OpenAPI Spec
        • Import cURL
        • Import Markdowns
        • Import from Insomnia
        • Import from apiDoc
        • Import .har File
        • Import WSDL
  • Design APIs
    • Overview
    • Create a New API Project
    • Endpoint Basics
    • APl Design Guidelines
    • Module
    • Configure Multiple Request Body Examples
    • Components
    • Common Fields
    • Global Parameters
    • Endpoint Change History
    • Comments
    • Batch Endpoint Management
    • Custom Protocol API
    • Schemas
      • Overview
      • Create a New Schema
      • Build a Schema
      • Generate Schemas from JSON Etc
      • oneOf, allOf, anyOf
      • Using Discriminator
    • Security Schemes
      • Overview
      • Create a Security Scheme
      • Use the Security Scheme
      • Security Scheme in Online Documentation
    • Advanced Features
      • Custom Endpoint Fields
      • Associated Test Scenarios
      • Endpoint Status
      • Appearance of Parameter Lists
      • Endpoint Unique Identification
  • Develop and Debug APIs
    • Overview
    • Generating Requests
    • Sending Requests
    • Debugging Cases
    • Test Cases
    • Dynamic Values
    • Validating Responses
    • Design-First vs Request-First
    • Generating Code
    • Environments & Variables
      • Overview
      • Environment Management
      • Using Variables
    • Vault Secrets
      • Overview
      • HashiCorp Vault
      • Azure Key Vault
      • AWS Secrets Manager
    • Pre and Post Processors
      • Assertion
      • Extract Variable
      • Wait
      • Overview
      • Database Operations
        • Overview
        • MySQL
        • MongoDB
        • Redis
        • Oracle Client
      • Using Scripts
        • Overview
        • Pre Processor Scripts
        • Post Processor Scripts
        • Public Scripts
        • Postman Scripts Reference
        • Calling Other Programming Languages
        • Using JS Libraries
        • Visualizing Responses
        • Script Examples
          • Assertion Scripts
          • Using Variables
          • Modifying Requests
          • Other Examples
    • Dynamic Values Modules
  • Mock API Data
    • Overview
    • Smart Mock
    • Custom Mock
    • Mock Priority Sequence
    • Mock Scripts
    • Cloud Mock
    • Self-Hosted Runner Mock
    • Mock Language (Locales)
  • API Testing
    • Overview
    • Test Scenarios
      • Create a Test Scenario
      • Pass Data Between Requests
      • Flow Control Conditions
      • Sync Data from Endpoints and Endpoint Cases
      • Import Endpoints and Endpoint Cases from Other Projects
      • Export Test Scenarios
    • Run Test Scenarios
      • Run a Test Scenario
      • Run Test Scenarios in Batch
      • Manage Runtime Environment of APIs from Other Projects
      • Data-Driven Testing
      • Scheduled Tasks
    • Test Suite
      • Overview
      • Create A Test Suite
      • Orchestrate Test Suite
      • Run Test Suites Locally
      • Run Test Suites Via CLI
      • Scheduled tasks
    • Test Reports
      • Test Reports
    • Test APIs
      • Integration Testing
      • Performance Testing
      • End-to-End Testing
      • Regression Testing
      • Contract Testing
    • Apidog CLI
      • Overview
      • Installing and Running Apidog CLI
      • Apidog CLI Options
    • CI CD
      • Overview
      • Integrate with Gitlab
      • Integrate with Jenkins
      • Trigger Test by Git Commit
      • Integrate with Github Actions
  • Publish API Docs
    • Overview
    • API Technologies Supported
    • Quick Share
    • Viewing API Documentation
    • Markdown Documentation
    • Publishing Documentation Sites
    • Custom Layouts
    • Custom CSS, JavaScript, HTML
    • Custom Domain
    • LLM-Friendly Features
    • SEO Settings
    • Advanced Settings
      • Documentation Search
      • CORS Proxy
      • Integrating Google Analytics with Doc Sites
      • Folder Tree Settings
      • Visibility Settings
      • Embedding Values in Document URLs
    • API Versions
      • Overview
      • Creating API Versions
      • Publishing API Versions
      • Sharing Endpoints with API Versions
  • Send Requests
    • Overview
    • SSE Debugging
    • MCP Client
    • Socket.IO
    • WebSocket
    • Webhook
    • SOAP or WebService
    • GraphQL
    • gRPC
    • Use Request Proxy Agents for Debugging
    • Create Requests
      • Request History
      • Request Basics
      • Parameters and Body
      • Request Headers
      • Request Settings
      • Debug Requests
      • Saving Requests as Endpoints
      • HTTP/2
    • Response and Cookies
      • Viewing API Responses
      • Managing Cookies
      • Overview
    • Authentication and Authorization
      • Overview
      • CA and Client Certificates
      • Authorization Types
      • Digest Auth
      • OAuth 1.0
      • OAuth 2.0
      • Hawk Authentication
      • Kerberos
      • NTLM
      • Akamai EdgeGrid
  • Branches
    • Overview
    • Creating a Sprint Branch
    • Testing APIs in a Branch
    • Designing APIs in a Branch
    • Merging Sprint Branches
    • Managing Sprint Branches
  • AI Features
    • Overview
    • Enabling AI Features
    • Generating Test Cases
    • Modifying Schemas with AI
    • Endpoint Compliance Check
    • API Documentation Completeness Check
    • AI-Powered Field Naming
    • FAQs
  • Apidog MCP Server
    • Overview
    • Connect Apidog Project to AI
    • Connect Published Documentation to AI
    • Connect OpenAPI Files to AI
  • Best Practices
    • Handling API Signatures
    • Accessing OAuth 2.0 Protected APIs
    • Collaboration Workflow
    • Managing Authentication State
  • Offline Space
    • Overview
  • Administration
    • Managing Teams
      • Managing Teams
      • Managing Team Members
      • Member Roles & Permission Settings
      • Team Activities
      • Team Resources
        • General Runner
        • Team Variables
        • Request Proxy Agent
      • Real-time Collaborations
        • Team Collaboration
    • Onboarding Checklist
      • Basic Concepts
      • Onboarding Guide
    • Managing Projects
      • Managing Projects
      • Managing Project Members
      • Notification Settings
      • Project Resources
        • Database Connection
        • Git Connection
    • Managing Organization
      • Managing Organization
      • Single Sign-On (SSO)
        • SSO Overview
        • Configuring Microsoft Entra ID
        • Configuring Okta
        • Configuring SSO for an Organization
        • Managing User Accounts
        • Mapping Groups to Teams
      • SCIM Provisioning
        • Introduction to SCIM Provisioning
        • Microsoft Entra ID
        • Okta
      • Plans Management
        • Billing Managers in Organizations
      • Organization Resources
        • Self-Hosted Runner
  • Billing
    • Overview
    • Credits
    • Alternative Payment Methods
    • Managing Subscriptions
    • Upgrading Your Plan
    • Moving Paid Teams to Organizations
  • Data & Security
    • Data Storage and Security
    • User Data Privacy and Security
    • Request Routing and Data Security
  • Add-ons
    • API Hub
    • Apidog Intellij IDEA Plugin
    • Browser Extension
      • Chrome
      • Microsoft Edge
    • Request Proxy
      • Request Proxy in Web
      • Request Proxy in Shared Docs
      • Request Proxy in Client
  • Account & Preferences
    • Account Settings
    • Generating OpenAPI Access Token
    • Notification
    • Language Settings
    • Hot Keys
    • Network Proxy Configuration
    • Backing Up Data
    • Updating Apidog
    • Deleting Account
    • Experimental Features
  • References
    • API Design-First Approach
    • Apidog OpenAPI Specificaiton Extensions
    • JSONPath
    • XPath
    • Regular Expressions
    • JSON Schema
    • CSV File Format
    • Installing Java Environment
    • Runner Deployment Environment
    • Apidog flavored Markdown
  • Apidog Europe
    • Apidog Europe
  • Support Center
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
Discord Community
Slack Community
X / Twitter
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
  1. Develop and Debug APIs

Test Cases

Starting from Apidog version 2.7.29, you can now add test cases directly on the endpoint details page.
Each test case represents a set of request parameters for the endpoint. Users can organize and manage all test cases systematically, then run them with one click to complete testing for the current endpoint.
Test Cases vs. Debug Cases
Test cases
Purpose: To verify whether the endpoint behaves as expected across different request scenarios, focusing on comprehensiveness.
Covers a wide range of scenarios: positive, negative, boundary, and security.
Usually less frequently modified or executed.
Debug cases
Purpose: To quickly verify endpoint responses during development or troubleshooting, focusing on speed.
Generally limited to basic scenarios such as success and failure.
Often modified and run frequently.

Creating Test Cases#

You can create test cases in several ways:

1. Manual Creation#

In the Test Cases tab of the endpoint details page, click + Add Case to manually create one.

2. Import from Debug Cases#

When adding a test case, you can choose Import from Debug Cases to copy or move the existing debug cases into test cases.
Copy: Use this when you still need the debug case for quick validation but also want it as a test case.
Move: Use this when the debug case is no longer frequently used for debugging and was primarily written for testing exceptions. This directly converts it into a test case, making migration quicker if test cases were originally created as debug cases.

Test Case Details#

A test case contains the following information:
Group: Organized by test purpose (positive, negative, boundary, etc.).
Case Name: The name of the test case.
Request Parameters: Path, Query, Header, and form-data Body parameters.
Request Body: Supports RAW, JSON, XML, etc.
Pre/Post Processors
Response Validation: Enable/disable validation and specify response components to be validated.
[!NOTE]
Since test cases are less frequently updated, they must be manually synchronized with endpoint changes. For example, if a new field is added to the endpoint, you'll need to click Update in the test case to update it.
Any edits to test case details must be saved by clicking Save. If there are unsaved changes, the system will prompt you.

Managing Test Cases#

In the Test Cases tab, you can manage all created test cases. Use the search and filter features in the upper left corner to easily find the test cases you need. You can also use the group tab to quickly view test cases by group. For operations on specific test cases:
Single Test Case: You can open a new tab to view, modify, and run a test case. Basic operations include copying, moving test case to other groups, copying the cURL of the test case, and deleting the test case.
Multiple Test Cases: When you select multiple test cases in the list, action buttons will appear in the upper right corner, allowing you to batch-group, delete, and synchronize with endpoint updates.

Running Test Cases#

When viewing a test case, click the Run button to send a request with its parameters. The actual response will then be displayed.
You can also use Run All or select multiple test cases from the list and run them together. The interface will show which cases are currently running and which have results.
After a batch run, you can open a test case to view its execution results directly.

Test Reports#

After running tests in bulk, you can check all historical reports in the Test Reports at the top right.
Click a report to view detailed results, helping with issue tracing and analysis.
An overview of how test cases works:

Best Practices for Single Endpoint Testing#

Single endpoint testing usually involves two roles: backend developers and QA engineers.
Backend Developers: Write and debug endpoint code.
QA Engineers: Perform comprehensive API testing and identify issues.
With Apidog now supporting test cases for endpoints, the workflow can be more efficient:
QA engineers can directly write and manage unit test cases within the endpoint documentation.
Developers can use existing test cases to run tests, view results, and fix issues themselves — without waiting for QA engineer feedback or lengthy communication.
Best Practice Workflow:
This workflow can improve collaborative efficiency:
1.
Test cases can be written right after endpoint documentations are finalized, visible to all team members in Apidog.
2.
Developers can test endpoints themselves after debugging—no need to wait for QA engineers.
3.
Developers can fix issues directly based on test results—no extra tickets or handoffs required.
4.
Clear test results make problem explanations straightforward, avoiding miscommunication.
Modified at 2026-01-14 09:10:00
Previous
Debugging Cases
Next
Dynamic Values
Built with