Optimized HyperExecute docs for API Testing

Author: salmanlt

docs/getting-started-with-agent-to-agent-testing.md

@@ -53,10 +53,15 @@ TestMu AI [Agent Testing](https://www.testmuai.com/agent-testing/) Platform vali
 
 It is the first platform to test chat, voice, phone, and image agents in one place. Connecting an agent takes three inputs and no SDK: upload the documents that describe it, define its intended behavior, and point the platform at its endpoint or phone number.
 
-<div className="ytframe"> 
-<div className="youtube" data-embed="DrdnovKzUQY" data-loading-attribute="eager">
-  <div className="play-button"></div>
-</div>
+<div style={{ width: "50%", aspectRatio: "16 / 9", margin: "20px auto", borderRadius: "8px", overflow: "hidden" }}>
+  <iframe
+    style={{ display: "block", width: "100%", height: "100%", border: 0 }}
+    src="https://www.youtube-nocookie.com/embed/DrdnovKzUQY?rel=0&showinfo=0"
+    title="Agent Testing by TestMu AI: The QA Layer AI Agents Never Had"
+    loading="lazy"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowFullScreen
+  ></iframe>
 </div>
 
 

docs/hyperexecute-api-testing.md

@@ -1,9 +1,9 @@
 ---
 id: hyperexecute-api-testing
-title: Boost Your API Testing Efficiency with HyperExeucte
+title: How to Perform API Testing With REST Assured on HyperExecute
 hide_title: false
-sidebar_label: API Testing
-description: Master API Testing with HyperExecute! This technical doc explains API test automation using Hyperexecute. Learn how to ensure efficient API testing.
+sidebar_label: "REST Assured"
+description: Run a REST Assured (Java + Maven) API test suite on HyperExecute. Download the CLI, set your credentials, configure hyperexecute.yaml, and trigger a cloud run.
 keywords:
   - hyperexecute api testing
   - api automation hyperexecute
@@ -25,6 +25,7 @@ import {YOUR_LAMBDATEST_USERNAME, YOUR_LAMBDATEST_ACCESS_KEY} from "@site/src/co
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+import DocCard from '@site/src/component/DocCard';
 
 
 <script type="application/ld+json"
@@ -51,88 +52,63 @@ import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
     }}
 ></script>
 
-An API acts as a middleman between different software applications, allowing them to communicate and exchange data. Just like any other part of a software system, APIs need to be thoroughly tested to ensure they function as intended.
+To run REST Assured API tests on HyperExecute, download the HyperExecute CLI, set your TestMu AI credentials, point the CLI at a `hyperexecute.yaml` configuration, and trigger the run. REST Assured is a Java library for testing REST APIs, and HyperExecute is the TestMu AI test orchestration platform that discovers your tests, runs the suite on its cloud grid, and reports the results in the dashboard.
 
-## Why is API Testing Important?
+Run your own REST Assured (Java + Maven) project or the ready-made sample used in the steps below.
 
-API testing is crucial for several reasons:
+## Prerequisites
 
-- **Ensures application functionality:** It verifies that the API delivers the correct data and behaves as expected under various conditions.
-- **Catches bugs early:** By testing APIs early in the development process, you can identify and fix issues before they impact the overall application.
-- **Improves application reliability:** Robust API testing leads to a more stable and reliable application for end users.
+Before you start, make sure you have:
 
-## How to Automate API Testing with Rest Assured?
+- **Java (JDK 8 or above)** and **Maven** installed and on your `PATH` (`java -version` and `mvn -version` should both succeed). REST Assured is a Java library, so the suite builds with Maven.
+- **Git**, to clone the sample repository.
+- **A TestMu AI account.** Get your `LT_USERNAME` and `LT_ACCESS_KEY` from the [TestMu AI Profile](https://www.testmuai.com/login/?redirectTo=https://accounts.lambdatest.com/details/profile). You will export them in Step 3.
 
-REST-Assured, a robust Java library, simplifies interacting with RESTful web services for testing purposes. It provides intuitive syntax for constructing requests and validating responses, streamlining API testing within Java environments.
+## How the REST Assured sample works
 
-It is majorly used for:
-- Writing automated API tests
-- Validating REST API endpoints
-- Ensuring API reliability, performance, and security
+The sample is a Java + Maven project that uses REST Assured with TestNG. REST Assured sends HTTP requests (GET, POST, PUT, DELETE) and asserts on the responses using a readable `given().when().then()` syntax. For example, this call fetches a resource and asserts that the API returns a `200` status code:
 
-REST-Assured seamlessly integrates with popular testing frameworks like JUnit and TestNG, enabling organized and efficient test execution with its core capabilities:
-
-- Sending various HTTP requests (GET, POST, PUT, DELETE, etc.)
-- Parsing various response formats (JSON, XML, etc.)
-- Asserting response status codes and body content
-- Handling authentication mechanisms
-- Supporting data-driven testing with external data sources
-
-For e.g. REST-Assured provides function to write get method such as `given().when().get(url).then().log().all();` This will help you to call a get request to fetch all the data from the API. Once the Call is complete you can either verify using the response of that call or by checking the status of the request.
-
-```bash
+```java
 given().when().get(url).then().assertThat().statusCode(200);
 ```
 
-- **Setting Base URI:** `RestAssured.baseURI` specifies the common part of API endpoints, avoiding repetition.
+- `RestAssured.baseURI` sets the common part of your endpoints so you don't repeat it.
+- `given()` sets up the request, `when()` sends it, and `then()` handles the response and assertions.
+- `log().all()` prints the request and response for debugging, and `extract().response().asString()` returns the response body as a string.
 
-- **Constructing Request:**
-    - **given()** initiates test case setup.
-    - **when()** sends the HTTP request (GET in this case).
-- **Capturing Response:**
-    - **then()** handles response handling and assertions.
-    - **log().all()** logs request and response details for debugging.
-    - **extract().response().asString()** extracts the response body as a string.
+You don't need to change the test code to run it on HyperExecute. The steps below build the suite with Maven and hand execution to the HyperExecute grid through `hyperexecute.yaml`.
 
-## How to Test API on HyperExecute?
+## Run the REST Assured suite on HyperExecute
 
-### Step 1: Setup Your Test Suite
+### Step 1: Clone the sample repository
 
-You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+Clone the REST Assured API testing sample from the TestMu AI GitHub repository, or use your own project.
 
 :::tip Sample repo
 
-Download or Clone the code sample for the Maestro framework from the <BrandName /> GitHub repository to run the tests on the HyperExecute.
+Download or clone the REST Assured API testing sample from the TestMu AI GitHub repository to run the tests on HyperExecute.
 
 <a href="https://github.com/LambdaTest/hyp-api-testing" className="github__anchor"><img loading="lazy" src={require('../assets/images/icons/github.png').default} alt="Image" className="doc_img"/> View on GitHub</a>
 
 :::
 
-### Step 2: Setup the CLI in your Test Suite
-
-After cloning / downloading the sample repo, you need to setup the CLI and the environment variables.
+### Step 2: Download the HyperExecute CLI
 
-#### Download the HyperExecute CLI
-
-The CLI is used for triggering the tests on HyperExecute. It is recommend to download the CLI binary on the host system and keep it in the root directory of the suite to perform the tests on HyperExecute.
-
-You can download the CLI for your desired platform from the below mentioned links:
+The CLI triggers your tests on HyperExecute. Download the binary for your platform and keep it in the **root directory** of the test suite.
 
 | Platform | HyperExecute CLI |
 | ---------| ---------------- |
 | Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
-| MacOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
 | Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
 
-#### Setup Environment Variable
+### Step 3: Set your TestMu AI credentials
 
-Now, you need to export your environment variables *LT_USERNAME* and *LT_ACCESS_KEY* that are available in the [<BrandName /> Profile page](https://www.testmuai.com/login/?redirectTo=https://accounts.lambdatest.com/details/profile).
-
-Run the below mentioned commands in your terminal to setup the CLI and the environment variables.
+Export the `LT_USERNAME` and `LT_ACCESS_KEY` from your TestMu AI Profile (linked in the [Prerequisites](#prerequisites)) as environment variables. The CLI reads these to authenticate your run.
 
 <Tabs className="docs__val">
 
-<TabItem value="bash" label="Linux / MacOS" default>
+<TabItem value="bash" label="Linux / macOS" default>
 
   <div className="lambdatest__codeblock">
     <CodeBlock className="language-bash">
@@ -143,56 +119,72 @@ export LT_ACCESS_KEY="${ YOUR_LAMBDATEST_ACCESS_KEY()}"`}
 
 </TabItem>
 
-<TabItem value="powershell" label="Windows" default>
+<TabItem value="powershell" label="Windows (PowerShell)">
 
   <div className="lambdatest__codeblock">
     <CodeBlock className="language-powershell">
-  {`set LT_USERNAME="${ YOUR_LAMBDATEST_USERNAME()}"
-set LT_ACCESS_KEY="${ YOUR_LAMBDATEST_ACCESS_KEY()}"`}
+  {`$env:LT_USERNAME = "${ YOUR_LAMBDATEST_USERNAME()}"
+$env:LT_ACCESS_KEY = "${ YOUR_LAMBDATEST_ACCESS_KEY()}"`}
   </CodeBlock>
 </div>
 
 </TabItem>
 </Tabs>
 
-### Step 3: Configure YAML in your Test Suite
+### Step 4: Review the hyperexecute.yaml
+
+The `hyperexecute.yaml` at the repository root tells HyperExecute how to build the suite, discover tests, and run them. It ships ready to use. Review it to see the `pre` (Maven build), `testDiscovery`, and `testRunnerCommand` steps.
 
 ```yaml reference title="hyperexecute.yaml"
 https://github.com/LambdaTest/hyp-api-testing/blob/master/hyperexecute.yaml
 ```
 
-### Step 4: Execute your Test Suite
+### Step 5: Trigger the run from the CLI
 
-> **NOTE :** In case of MacOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
-
-Run the below command in your terminal at the root folder of the project:
+From the root folder of the project, run the CLI against your YAML file:
 
 ```bash
 ./hyperexecute --config RELATIVE_PATH_OF_YOUR_YAML_FILE
 ```
 
-OR use this command if you have not exported your username and access key in the step 2.
+If you did not export your credentials in Step 3, pass them inline instead:
 
 <div className="lambdatest__codeblock">
   <CodeBlock className="language-bash">
     {`./hyperexecute --user ${ YOUR_LAMBDATEST_USERNAME()} --key ${ YOUR_LAMBDATEST_ACCESS_KEY()} --config RELATIVE_PATH_OF_YOUR_YAML_FILE `}
   </CodeBlock>
 </div>
 
-### Step 5: Monitor and Validate the Test Execution
+:::note macOS permissions
+
+If macOS reports **permission denied** when you run the CLI, make it executable with `chmod u+x ./hyperexecute`. If a security popup appears, allow the binary from **System Preferences** → **Security & Privacy** → **General**.
+
+:::
+
+### Step 6: Monitor the run in the dashboard
 
-Visit the [HyperExecute Dashboard](https://www.testmuai.com/login/?redirectTo=https://hyperexecute.lambdatest.com/hyperexecute) and check your Job status. 
+Open the [HyperExecute Dashboard](https://www.testmuai.com/login/?redirectTo=https://hyperexecute.lambdatest.com/hyperexecute) and find your job. A successful run shows the job as **Completed** with passing tests, and the **pre**, **scenario**, and **post** stages available as logs. Open each stage to validate the API responses your suite tested.
 
-You can validate the tested API via the pre, post, and scenrios logs in the dashboard.
+#### Pre-run logs
 
-#### pre
+<img loading="lazy" src={require('../assets/images/hyperexecute/integration/products/api/1.png').default} alt="HyperExecute dashboard showing pre-run logs"  width="1920" height="868" className="doc_img"/>
 
-<img loading="lazy" src={require('../assets/images/hyperexecute/integration/products/api/1.png').default} alt="automation-dashboard"  width="1920" height="868" className="doc_img"/>
+#### Scenario logs
 
-#### scenario
+<img loading="lazy" src={require('../assets/images/hyperexecute/integration/products/api/2.png').default} alt="HyperExecute dashboard showing scenario logs"  width="1920" height="868" className="doc_img"/>
 
-<img loading="lazy" src={require('../assets/images/hyperexecute/integration/products/api/2.png').default} alt="automation-dashboard"  width="1920" height="868" className="doc_img"/>
+#### Post-run logs
 
-#### post
+<img loading="lazy" src={require('../assets/images/hyperexecute/integration/products/api/3.png').default} alt="HyperExecute dashboard showing post-run logs"  width="1920" height="868" className="doc_img"/>
 
-<img loading="lazy" src={require('../assets/images/hyperexecute/integration/products/api/3.png').default} alt="automation-dashboard"  width="1920" height="868" className="doc_img"/>
+## Related resources
+
+<div style={{ display: 'flex', gap: '20px', flexWrap: 'wrap', marginBottom: '20px' }}>
+  <DocCard heading="Getting started with HyperExecute" link="/support/docs/getting-started-with-hyperexecute/" description="Set up HyperExecute and trigger your first job on the grid." />
+  <DocCard heading="hyperexecute.yaml parameters" link="/support/docs/hyperexecute-yaml-parameters/" description="Reference for every YAML key, with examples you can copy." />
+</div>
+
+<div style={{ display: 'flex', gap: '20px', flexWrap: 'wrap' }}>
+  <DocCard heading="Auto-split test execution" link="/support/docs/hyperexecute-auto-split-strategy/" description="Distribute tests across parallel machines automatically." />
+  <DocCard heading="HyperExecute FAQs" link="/support/docs/hyperexecute-faqs/" description="Common questions on YAML, the CLI, and the platform." />
+</div>