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,99 +20,223 @@ 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" />
+# Using Docker Compose 🐳
 
-# 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.
+A sample CRUD app to test Keploy integration capabilities using FastHttp and Postgres
 
 <InstallReminder />
 
-### Clone the sample CRUD application 🧪
+### Clone a 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! 🎥
 
-#### Point the app to local Postgres
+Fire up the application and Postgres instance with Keploy. Keep an eye on the two key flags:
+`-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.
+
+🔥 Challenge time! Generate some test cases. How? Just **make some API calls**. Postman, Hoppscotch or even curl - take your pick!
+
+#### Generate a Test Case
 
 ```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! 🎥
+Here's a peek of what you get:
+
+```json
+{"id": 1, "name": "Author Name"}
+```
+
+🎉 Woohoo! With a simple API call, you've crafted a test case with a mock! Dive into the Keploy directory and feast your eyes on the newly minted `test-1.yml` and `mocks.yml`
+
+```yaml
+version: api.keploy.io/v1beta2
+kind: Http
+name: test-1
+spec:
+  metadata: {}
+  req:
+    method: POST
+    proto_major: 1
+    proto_minor: 1
+    url: http://localhost:8080/authors
+    header:
+      Accept: "*/*"
+      Content-Length: "23"
+      Content-Type: application/json
+      Host: localhost:8080
+      User-Agent: curl/7.68.0
+    body: |-
+      {"name":"Author Name"}
+    body_type: ""
+  resp:
+    status_code: 201
+    header:
+      Content-Type: application/json
+    body: '{"id": 1, "name": "Author Name"}'
+    body_type: ""
+    status_message: ""
+    proto_major: 0
+    proto_minor: 0
+  objects: []
+  assertions:
+    noise:
+      - header.Date
+  created: 1696834280
+```
+
+#### Fetch Books from App
 
 ```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.
+Spotted the new test and mock files in your project? High five! 🙌
+
+### Run Tests
 
-If you're seeing logs that resemble the ones below, you're on the right track:
+Time to put things to the test 🧪
+
+```bash
+keploy test -c "docker compose up" --container-name "fasthttp_app" --build-delay 50 --delay 10
+```
 
-<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' }} />
+> The `--delay` flag? Oh, that's just giving your app a little breather (in seconds) before the test cases come knocking.
 
-Alright! With the app alive and kicking, let's weave some test cases. Making some API calls! Postman, Hoppscotch,
+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!✨👩‍💻👨‍💻✨
 
-or even the classic curl - take your pick!
+### Wrapping it up 🎉
 
-Time to create some users and books:
+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.😊🚀
 
-### Generate traffic
+Happy coding! ✨👩‍💻👨‍💻✨
 
-#### Post Requests
+<SectionDivider />
+
+---
+
+# Running App Locally on Linux/WSL 🐧
+
+<ProductTier tiers="Open Source, Enterprise" offerings="Self-Hosted, Dedicated" />
+
+A sample CRUD app to test Keploy integration capabilities using FastHttp and Postgres
+
+<InstallReminder />
+
+### Clone a 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 tad more thrilling, we'll have the database (Postgres) chill on Docker. Ready? Let's get the party started!🎉
+
+> 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 breathe life into your Postgres container. A simple spell should do the trick:
+
+```bash
+docker compose up -d postgres
 ```
 
+### 📼 Roll the Tape - Recording Time!
+
+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
+Ready, set, record! Here's how:
 
 ```bash
-curl -i http://localhost:8080/books
+keploy record -c "./app"
 ```
 
-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`.
+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.
+
+Alright, magician! With the app alive and kicking, let's weave some test cases. The spell? Making some API calls! Postman, Hoppscotch, or the classic curl - pick your wand.
 
-### 🏃‍♀️ Run the Tests!
+#### Generate a Test Case
 
-Time to put it all to the test:
+✨ A pinch of POST magic:
 
 ```bash
-keploy test -c "./app" --delay 5
+curl --request POST \
+--url http://localhost:8080/authors \
+--header 'content-type: application/json' \
+--data '{"name":"Author Name"}'
 ```
 
-> That `--delay` flag? Just a little pause (in seconds) to let your app catch its breath before the test cases start rolling in.
+And... voila! An Author entry appears:
 
-When all is said and done, your test results should look a little something like this:
+```json
+{"id": 1, "name": "Author Name"}
+```
+
+Give yourself a pat on the back! With that simple spell, you've conjured up a test case with a mock! Explore the **Keploy directory** and you'll discover your handiwork in `test-1.yml` and `mocks.yml`.
+
+Now, the real fun begins. Let's weave more spells!
+
+#### Fetch Books from App
+
+🚀 Follow the URL road...!
+
+```bash
+curl --request GET --url http://localhost:8080/books
+```
+
+Did you spot the new test and mock scrolls in your project library? Awesome! 👏
 
-<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' }} />
+### Run Tests 🏁
 
-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!
+Ready to put your spells to the test?
+
+```bash
+keploy test -c "./app" --delay 10
+```
+
+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! ✨👩‍💻👨‍💻✨
 
 ### 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 .