Apidog Docs
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
HomeLearning CenterSupport CenterAPI ReferencesDownloadChangelog
HomeLearning CenterSupport CenterAPI ReferencesDownloadChangelog
Discord Community
Slack Community
X / Twitter
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
  1. Develop and Debug APIs
  • Apidog Learning Center
  • Get started
    • Introduce Apidog
    • Navigating Apidog
    • Basic concepts in Apidog
    • Quick Start
      • Overview
      • Specify a new endpoint
      • Make a request to the endpoint
      • Add an assertion
      • Create a test scenario
      • Share your API documentation
      • Explore more
      • Send a request and save as an endpoint
    • Migration to Apidog
      • Overview
      • Manual import
      • Scheduled import
      • Import options
      • Export data
      • Import from...
        • Import from Postman
        • Import OpenAPI (Swagger) spec
        • Import cURL
        • Import Markdowns
        • Import from Insomnia
        • Import from apiDoc
        • Import .har file
        • Import WSDL
  • Design APIs
    • Overview
    • Organization method of endpoints
    • Endpoint basics
    • Module
    • Configure multiple request body examples
    • Components
    • Common fields
    • Global parameters
    • Endpoint change history
    • Comments
    • Batch endpoint management
    • Schemas
      • Overview
      • Create a new schema
      • Build a schema
      • Generate Schemas from JSON etc.
      • oneOf, allOf, anyOf
    • 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
    • Generate requests
    • Send requests
    • Debug cases
    • Test cases
    • Dynamic values
    • Validate responses
    • Design-first Mode & Request-first Mode
    • Generate code
    • Environments & variables
      • Overview
      • Environment Management
      • Using variables
    • Vault secrets
      • Overview
      • HashiCorp Vault
      • Azure Key Vault
      • AWS Secrets Manager
    • Pre/Post processors
      • Overview
      • Assertion
      • Extract variable
      • Wait
      • 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 in scripts
          • Using scripts to modify request messages
          • 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 reports
    • Test scenarios
      • Create a test scenario
      • Pass data between requests
      • Flow control conditions
      • Sync data from endpoints/endpoint cases
      • Import endpoints/endpoint cases from other projects
      • Export test scenarios
    • Run test scenarios
      • Run a test scenario
      • Data-driven testing
      • Run test scenarios in batch
      • Scheduled tasks
      • Manage the runtime environment of APIs from other projects
    • Test APIs
      • Integration testing
      • Performance testing
      • End-to-end testing
      • Regression testing
    • Apidog CLI
      • Overview
      • Installing and running Apidog CLI
      • Apidog CLI Options
    • CI/CD
      • Overview
      • Integrate with Github Actions
      • Integrate with Jenkins
      • Integrate with Gitlab
      • Trigger Test by Git Commit
  • Publish API Docs
    • Overview
    • API Technologies Supported
    • Quick share
    • View the API documentation
    • Markdown documentations
    • Publish docs 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
      • Create API versions
      • Publish API versions
      • Share endpoints with API versions
  • Send requests
    • Overview
    • SSE debugging
    • Socket.IO
    • WebSocket
    • Webhook
    • SOAP/WebService
    • GraphQL
    • gRPC
    • Use request proxy agents for debugging
    • Create requests
      • Request History
      • Request basics
      • Parameters and body
      • Request headers
      • Request settings
      • Debug requests
      • Save the request as an endpoint
      • HTTP/2
    • Response and cookies
      • Overview
      • API response in Apidog
      • Create and send cookies
    • Authentication and authorization
      • Overview
      • CA and client certificates
      • Authorization types supported by Apidog
      • Digest Auth
      • OAuth 1.0
      • OAuth 2.0
      • Hawk Authentication
      • Kerberos
      • NTLM
      • Akamai EdgeGrid
  • Branches
    • Overview
    • Create a new sprint branch
    • Test APIs in a branch
    • Design API in a branch
    • Merge sprint branches
    • Manage sprint branches
  • AI Features
    • Overview
    • Enable AI features
    • Modify schemas with AI
    • FAQs
  • Apidog MCP Server
    • Overview
    • Connect API Specification within Apidog Project to AI via Apidog MCP Server
    • Connect Online API Documentation Published by Apidog to AI via Apidog MCP Server
    • Connect OpenAPI Files to AI via Apidog MCP Server
  • Best practices
    • How to handle API signatures
    • How to access OAuth 2.0 protected APIs
    • Apidog collaboration workflow
    • Managing authentication state in Apidog
  • Offline Space
    • Overview
  • Administration
    • Onboarding Checklist
      • Basic Concepts
      • Onboarding Guide
    • 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
    • Managing Projects
      • Managing Projects
      • Managing Project Members
      • Notification Settings
      • Project Resources
        • Database Connection
        • Git Connection
    • Managing organization
      • Single Sign-On (SSO)
        • SSO Overview
        • Configure Microsoft Entra ID
        • Configure Okta
        • Configure SSO for an Organization
        • Managing user accounts
        • Mapping Groups to Teams
      • SCIM Provisioning
        • Intro to SCIM Provisioning
        • Microsoft Entra ID
        • Okta
      • Organization Resources
        • Self-hosted Runner
      • Plans management
        • Billing managers in organization
  • Billing
    • Overview
    • Credits
    • Unable to use credit cards?
    • Managing subscriptions
    • Upgrade plan
    • How to move a paid team to a organization?
  • Data & Security
    • Where is Apidog's data stored, and how is data security ensured?
    • How is user data stored? Will this data be public? Or will it be private? Will all data be stored in the cloud?
    • When sending requests, do they go through the Apidog server? Is data security ensured?
  • Add-ons
    • API Hub
    • Apidog Intellij IDEA plugin
    • Browser Extension
      • Chrome
      • Microsoft Edge
    • Request Proxy
      • Request proxy in Apidog web
      • Request proxy in shared docs
      • Request proxy in Apidog client
  • Account & preferences
    • Account settings
    • Generate OpenAPI access token
    • Notification
    • Language settings
    • Hot keys
    • Network proxy configuration
    • Data backup
    • Updating Apidog
    • Deleting account
    • Experimental Features
  • References
    • API-Design First Approach
    • Apidog OpenAPI/Swagger Specificaiton Extensions
    • JSONPath
    • XPath
    • Regular Expressions
    • JSON Schema
    • CSV File Format
    • Install Java Environment
    • Runner deployment environment
    • Apidog flavored Markdown
  • Apidog Europe
    • Apidog Europe
  • Support Center
  1. Develop and Debug APIs

Test cases

Starting from Apidog version2.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.
Difference Between "Test cases” and "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Β 2025-09-17 06:10:40
Previous
Debug cases
Next
Dynamic values
Built with