# Test your app

{% hint style="info" %}
Use a Test App to safely try changes to your app before publishing. You create it from the App Detail page, choose an Environment (Live — default, or Test), and the system clones your current app into a separate test space.
{% endhint %}

## What is a Test App?

A Test App is a cloned copy of an existing app used only for validation. It:

* Appears under the Dev Environment menu
* Shows a “test” tag in the UI
* Mirrors the original app’s settings and configuration at the time of cloning
* Is isolated for access control (only granted users can use it)

{% hint style="warning" %}
Environment matters:

* Test (recommended): some features/permissions/APIs or modules may run in mock mode to avoid impacting live data.
* Live (default): operates on live data. Actions may affect your main app.
  {% endhint %}

## Prerequisites

* You already have an app: [Create an app](broken://pages/HGpkOALzklDoZPMahsSU)
* You have permission to create Test Apps for this app
* You understand the difference between Test vs. Live environments for Test Apps

## Create a Test App

1. Go to Developer Console → your App → App Detail
2. Click the Test button
3. In the Create Test App dialog, fill in:
   * Name: the display name of your Test App
   * Environment: Live (default) or Test
4. Click Create

What happens next:

* The system clones a Test App from the app you selected
* You are redirected to the Test App’s App Detail page (same layout as the main app, with an extra “test” tag)
* The Test App appears under the Dev Environment menu (all Test Apps are listed here)

### Screen

* Create Test App dialog

![Create Test App dialog](https://gitlab.silvertiger.tech/documents/open-platform/-/blob/document/.gitbook/assets/test-app-create-dialog.png)

* Test App Detail with "test" tag under Dev Environment menu

![Test App Detail with tag](https://gitlab.silvertiger.tech/documents/open-platform/-/blob/document/.gitbook/assets/test-app-detail-with-test-tag.png)

* Manage Test Users screen

![Manage Test Users screen](https://gitlab.silvertiger.tech/documents/open-platform/-/blob/document/.gitbook/assets/test-users-management.png)

## What you can do in a Test App

* Edit App Information
  * Preview how changes would look on the Marketplace before you modify the main app
* Rotate Client credentials (Client ID/Client Secret)
  * Validate that your integrations still work with updated credentials
* Adjust Integrations/Permissions/Scopes
  * Verify your app continues to work with the configured permissions and scopes (including consent flows)
* Update Roles (in your system app)
  * Confirm the Test App still works after role changes
* Not available in a Test App
  * No Publish action
  * No Pricing Plans section

{% hint style="warning" %}
If you chose Environment = Live when creating the Test App, actions in the Test App can change live data and may impact the main app. Use Environment = Test to avoid affecting live data.
{% endhint %}

## Manage Test Users

Only users explicitly granted can access a Test App. Use the Test Users screen (available in the Test App) to control access.

To test with your configuration:

1. Add a Test User (grant access)
2. Sign in to the Test App using that Test User
3. Exercise the flows you want to verify (e.g., permissions, consent, integrations)

## Known differences and limitations

* No app version control in a Test App (unlike the main app)
* No publish flow; Pricing Plans are hidden
* When Environment = Test, certain features/permissions/APIs or modules may be mocked to bypass live-only constraints

## Best practices

* Prefer Environment = Test for experiments; use Live only when necessary and with full awareness of impact
* Restrict access with Test Users; remove access when testing is complete
* Verify configuration parity with your main app before testing:
  * Client type, Redirect URIs, Allowed origins
  * Audience/Resource Server, Scopes/Permissions, Roles and consent settings
* Rotate Client credentials in the Test App first; update dependent integrations and verify redirect flows
* Use separate Webhook endpoints for Test vs. Live; avoid sensitive data in logs
* Label and separate test data; avoid using live customer data in Test
* Track intentional differences between the Test App and the main app (keep a short checklist)
* Clean up or archive stale Test Apps to reduce confusion and risk
* If you must test on Live environment, notify your team and monitor closely

## Troubleshooting

* Cannot access the Test App
  * Make sure your account is added in Test Users for this Test App
* Consent does not appear or fails
  * Re-check scopes/permissions and role assignment; note that some features may be mocked in Test environment
* Integration breaks after changing credentials
  * Update your app/integration configuration to use the new Client ID/Secret and verify Redirect URIs/origins
* Live data changed unexpectedly
  * You might be using Environment = Live. Create a new Test App with Environment = Test for safe validation

## Next steps

* When satisfied with results in the Test App, apply the same changes to your main app
* Continue to: [Publish your app](/openplatform/about-us/user-guide/oten-developer/6.-publish-your-app/publish-your-app.md)

## See also

* [Create an app](broken://pages/HGpkOALzklDoZPMahsSU)
* [Configure Resources & Security](broken://pages/m9BrVKv5fRL6DwaeFZiS)
* [OAuth and Permissions](https://gitlab.silvertiger.tech/documents/open-platform/-/blob/document/build-your-app/oauth-and-permissions.md)
* [Integrations](broken://pages/dLm01yWXauOSxKJhz5ez)
* [App versioning](/openplatform/comming-soon/app-versioning.md)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://oten.gitbook.io/openplatform/comming-soon/test-your-app.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.