fix(docs): add FastHTTP Postgres sample run and test instructions

src/components/QuickStartList.js

@@ -149,7 +149,6 @@ const quickstarts = [
     link: "/docs/quickstart/samples-mysql/#running-app-locally-on-linuxwsl-",
   },
 
-  /*
   {
     title: "FastHttp + Postgres",
     language: "Go",
@@ -158,7 +157,6 @@ const quickstarts = [
       "A sample CRUD application to demonstrate how seamlessly Keploy integrates with FastHttp and Postgres.",
     link: "/docs/quickstart/samples-fasthttp/#using-docker-compose-",
   },
-  */
 
   {
     title: "FastHttp + Postgres",

versioned_docs/version-4.0.0/quickstart/go-fasthttp-postgres.md

@@ -20,90 +20,191 @@ keyword:
 ---
 
 import InstallReminder from '@site/src/components/InstallReminder';
-import SectionDivider from '@site/src/components/SectionDivider';
 import ProductTier from '@site/src/components/ProductTier';
+import SectionDivider from '@site/src/components/SectionDivider';
 
-<ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
+# FastHTTP & Postgres Sample CRUD App
 
-# Running App Locally on Linux/WSL 🐧
+<ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
 
 This guide walks you through generating tests and DB mocks for a sample CRUD app built with FastHttp and Postgres using Keploy.
 
 <InstallReminder />
 
-### Clone the sample CRUD application 🧪
+## Using Docker Compose
+
+### Clone the sample CRUD App 🧪
 
 ```bash
 git clone https://github.com/keploy/samples-go.git && cd samples-go/fasthttp-postgres
 go mod download
 ```
 
-We'll be running our sample application right on Linux, but just to make things a tad more thrilling, we'll have the database (Postgres) chill on Docker. Ready? Let's get the party started! 🎉
+### Lights, Camera, Record! 🎥
+
+Start up the application and Keploy with a single command. Make sure to keep an eye on the two key flags:
 
-#### Point the app to local Postgres
+`-c`: Command to run the app (e.g., `docker compose up`).
 
-Update the Postgres URL to `localhost:5432` in `app.go` (mentioned at line 21 in the sample).
+`--container-name`: The container name in the `docker-compose.yml` for traffic interception.
 
-#### Start Postgres
+#### Capture the test case
 
 ```bash
-docker compose up postgres
+keploy record -c "docker compose up" --container-name "fasthttp_app" --build-delay 50
 ```
 
-#### Record with Keploy while running the app
+> `--build-delay` adds a buffer (in seconds) to allow images to build/pull and services to start before Keploy begins interception. If your services are already up, you can omit it.
+
+If you're seeing logs that resemble the ones below, you're on the right track:
+
+<img src="https://keploy-devrel.s3.us-west-2.amazonaws.com/Keploy_record_fastapi_golang.png" alt="Sample Keploy Record" width="100%" style={{ borderRadius: '5px' }} />
+
+Make API calls using **cURL**, **Postman**, or **Hoppscotch**.
+Keploy captures these requests to automatically generate test suites with test cases and data mocks.
+
+
+#### Generate a Test Case
+
+##### Post Requests
 
 ```bash
-go build -o app
+curl --request POST \
+--url http://localhost:8080/authors \
+--header 'content-type: application/json' \
+--data '{"name":"Author Name"}'
 ```
 
-### Lights, Camera, Record! 🎥
+This API call generates a test case along with the required mocks. You can find the generated files in the Keploy directory, including `test-1.yml` and `mocks.yml`.
+
+You can continue by making additional API calls to generate more test cases.
+
+##### Get Requests
 
 ```bash
-keploy record -c "./app"
+curl --request GET --url http://localhost:8080/books
 ```
 
-Keep an eye out for the `-c` flag! It's the command charm to run the app. Whether you're using `go run main.go` or the binary path like `./app`, it's your call.
 
-If you're seeing logs that resemble the ones below, you're on the right track:
+### 🏃‍♀️ Run the Tests
 
-<img src="https://keploy-devrel.s3.us-west-2.amazonaws.com/Keploy_record_fastapi_golang.png" alt="Sample Keploy Record" width="100%" style={{ borderRadius: '5px' }} />
+Time to run the testcases which were generated from the previous API calls..
+
+```bash
+keploy test -c "docker compose up" --container-name "fasthttp_app" --build-delay 50 --delay 10
+```
 
-Alright! With the app alive and kicking, let's weave some test cases. Making some API calls! Postman, Hoppscotch,
+> The `--delay` flag specifies the time (in seconds) Keploy waits before running the test cases after starting the application.
 
-or even the classic curl - take your pick!
+When all is said and done, your test results should look a little something like this:
 
-Time to create some users and books:
+<img src="https://keploy-devrel.s3.us-west-2.amazonaws.com/keploy_replay_test_fastapi_golang.png" alt="Sample Keploy Replay" width="100%" style={{ borderRadius: '5px' }} />
 
-### Generate traffic
+Final thoughts? Dive deeper! Try different API calls, tweak the DB response in the `mocks.yml`, or fiddle with the request or response in `test-x.yml`. Run the tests again and see the magic unfold!
 
-#### Post Requests
+### Wrapping it up 🎉
+
+Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible.
+
+Happy coding! ✨👩‍💻👨‍💻✨
+
+<SectionDivider />
+
+---
+
+## Running App Locally on Linux/WSL 🐧
+
+<ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
+
+This guide walks you through generating tests and DB mocks for a sample CRUD app built with FastHttp and Postgres using Keploy.
+
+<InstallReminder />
+
+### Clone the sample CRUD App 🧪
 
 ```bash
-curl -X POST -H "Content-Type: application/json" -d '{"name":"Author Name"}' http://localhost:8080/authors
+git clone https://github.com/keploy/samples-go.git && cd samples-go/fasthttp-postgres
+go mod download
+```
+
+We'll be running our sample application right on Linux, but just to make things a bit more thrilling, We'll have our database (Postgres) running on Docker. 
+
+> Note: This application requires the following database environment variables 
+> to be set in order to run correctly.
+>
+> Create a .env file in this directory with the following values:
+>
+> ```env
+> DB_HOST=localhost
+> DB_PORT=5432
+> DB_USER=postgres
+> DB_PASSWORD=password
+> DB_NAME=db
+> ```
+
+### Kickstart PostgresDB
+
+Let's start your Postgres container:
+
+```bash
+docker compose up -d postgres
 
 ```
+> The `-d` flag runs the PostgreSQL container in detached mode (in the background).
+
+This would start your postgres container which will be running on docker.
+
+### Lights, Camera, Record! 🎥
+
+#### First, build the application:
 
 ```bash
-curl -X POST -H "Content-Type: application/json" -d '{"title":"Book Title","author_id":1}' http://localhost:8080/books
+go build -o app
 ```
 
-#### Get Request
+#### Capture the test case
 
 ```bash
-curl -i http://localhost:8080/books
+keploy record -c "./app"
+```
+
+The `-c` flag specifies the command used to run the application. You can use either `go run main.go` or the compiled binary (for example, `./app`).
+
+If you're seeing logs that resemble the ones below, you're on the right track:
+
+<img src="https://keploy-devrel.s3.us-west-2.amazonaws.com/Keploy_record_fastapi_golang.png" alt="Sample Keploy Record" width="100%" style={{ borderRadius: '5px' }} />
+
+With the application running successfully, you can begin generating test cases by making API calls using tools such as **cURL**, **Postman**, or **Hoppscotch**.
+
+#### Generate a Test Case
+
+##### Post Requests
+
+```bash
+curl --request POST \
+--url http://localhost:8080/authors \
+--header 'content-type: application/json' \
+--data '{"name":"Author Name"}'
 ```
 
-Look at you go! With a few simple API calls, you've crafted test cases with mocks! Peek into the Keploy directory and behold the freshly minted `test-1.yml` and `mocks.yml`.
+This API call generates a test case along with the required mocks. You can find the generated files in the Keploy directory, including `test-1.yml` and `mocks.yml`.
 
-### 🏃‍♀️ Run the Tests!
+You can continue by making additional API calls to generate more test cases.
 
-Time to put it all to the test:
+##### Get Requests
 
 ```bash
-keploy test -c "./app" --delay 5
+curl --request GET --url http://localhost:8080/books
 ```
 
-> That `--delay` flag? Just a little pause (in seconds) to let your app catch its breath before the test cases start rolling in.
+
+### 🏃‍♀️ Run the Tests 
+
+You are now ready to run the generated test cases.
+
+```bash
+keploy test -c "./app" --delay 10
+```
 
 When all is said and done, your test results should look a little something like this:
 
@@ -113,6 +214,8 @@ Final thoughts? Dive deeper! Try different API calls, tweak the DB response in t
 
 ### Wrapping it up 🎉
 
-Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible
+Congrats on the journey so far! You've seen Keploy's power, flexed your coding muscles, and had a bit of fun too! Now, go out there and keep exploring, innovating, and creating! Remember, with the right tools and a sprinkle of fun, anything's possible. 
 
 Happy coding! ✨👩‍💻👨‍💻✨
+
+Hope this helps you out, if you still have any questions, reach out to us .