इस प्रोजेक्ट के बारे में
# Go REST क्लाइंट लाइब्रेरी
यह प्रोजेक्ट `.http` फाइलों में परिभाषित HTTP अनुरोधों को निष्पादित करने के लिए एक Go लाइब्रेरी और कमांड-लाइन टूल प्रदान करता है, जो JetBrains IDEs और VS Code REST क्लाइंट एक्सटेंशन द्वारा लोकप्रिय प्रारूप है। इसका उद्देश्य इन टूल्स के साथ पूर्ण संगतता है, जिससे डेवलपर्स IDE में मैनुअल परीक्षण और Go में स्वचालित एंड-टू-एंड (E2E) परीक्षण दोनों के लिए समान अनुरोध फाइलों का उपयोग कर सकें।
## मुख्य विशेषताएं
- **JetBrains/VS Code संगतता**: लोकप्रिय IDE एक्सटेंशन के समान सिंटैक्स, वेरिएबल्स और व्यवहार का उपयोग करके `.http` फाइलों को पार्स करता है।
- **वेरिएबल प्रतिस्थापन**: कस्टम वेरिएबल्स, पर्यावरण वेरिएबल्स, और `{{$guid}}`, `{{$randomInt}}`, `{{$timestamp}}`, और `{{$datetime}}` जैसे सिस्टम वेरिएबल्स का समर्थन करता है।
- **प्रतिक्रिया श्रृंखलन**: उसी फाइल में अन्य अनुरोधों से प्रतिक्रियाओं का संदर्भ लें, जैसे `{{authenticate.response.body.token}}`।
- **अनुरोध संदर्भ**: पूर्वापेक्षित अनुरोधों को चलाने के लिए `@ref` (प्रति रन कैश्ड) या `@forceRef` (हमेशा फिर से निष्पादित) का उपयोग करें, और फाइलों में नामित अनुरोधों को साझा करने के लिए `@import` का उपयोग करें।
- **अनुरोध नियंत्रण**: `@disabled` के साथ अनुरोधों को छोड़ें, `@sleep <ms>` के साथ भेजने से पहले रुकें, और `@loop` के साथ अनुरोधों को लूप करें।
- **प्रतिक्रिया सत्यापन**: `{{$any}}`, `{{$regexp}}`, और `{{$anyGuid}}` जैसे प्लेसहोल्डर्स के साथ `.hresp` फाइलों के विरुद्ध प्रतिक्रियाओं की तुलना करें।
- **प्रति फाइल एकाधिक अनुरोध**: अनुरोधों को `###` के साथ अलग करें।
- **E2E परीक्षण के लिए तैयार**: स्वचालित एकीकरण परीक्षणों के लिए डिज़ाइन किया गया।
## HTTP फ़ाइल प्रारूप
`.http` फाइलें HTTP अनुरोधों को परिभाषित करने वाली सादा पाठ फाइलें हैं। एक अनुरोध में वैकल्पिक नाम, विधि, URL, हेडर और बॉडी शामिल होते हैं।
```http
### अनुरोध नाम
METHOD URL
Header1: value1
बॉडी सामग्री
```
### उदाहरण
```http
@baseUrl = https://api.example.com
@userId = 123
### उपयोगकर्ता प्रोफ़ाइल प्राप्त करें
GET {{baseUrl}}/users/{{userId}}
Authorization: Bearer {{authToken}}
X-Request-ID: {{$guid}}
```
## लाइब्रेरी उपयोग
### स्थापना
```bash
go get github.com/bmcszk/go-restclient
```
### Go में अनुरोध निष्पादित करें
```go
package main
import (
"context"
"log"
"github.com/bmcszk/go-restclient"
)
func main() {
client, _ := restclient.NewClient(
restclient.WithVars(map[string]interface{}{
"authToken": "your-token-here",
}),
)
responses, _ := client.ExecuteFile(context.Background(), "requests.http")
for i, resp := range responses {
if resp.Error != nil {
log.Printf("अनुरोध %d विफल: %v", i+1, resp.Error)
} else {
log.Printf("अनुरोध %d: %d %s", i+1, resp.StatusCode, resp.Status)
}
}
}
```
### क्लाइंट विकल्प
```go
client, err := restclient.NewClient(
restclient.WithBaseURL("https://api.example.com"),
restclient.WithDefaultHeader("X-API-Key", "secret"),
restclient.WithHTTPClient(customHTTPClient),
restclient.WithVars(variables),
)
```
## CLI उपयोग
`restclient` CLI कमांड लाइन से `.http` फाइलें चलाता है।
### स्थापना
```bash
go install github.com/bmcszk/go-restclient/cmd/restclient@latest
```
### बुनियादी कमांड
```bash
restclient -f requests.http --all
restclient -f requests.http -n "get user"
restclient -f requests.http -i 0
restclient --version
```
### अनुरोध सूचीबद्ध करें
```bash
restclient -f requests.http --list
```
### एकल अनुरोध चलाएं
नाम से (केस-असंवेदनशील):
```bash
restclient -f requests.http -n "create user"
```
0-आधारित इंडेक्स द्वारा:
```bash
restclient -f requests.http -i 0
```
### कमांड-लाइन वेरिएबल्स
```bash
restclient -f requests.http -D token=abc123 -D env=prod
```
### पूर्वापेक्षित अनुरोध
```bash
restclient -f requests.http -n "get protected" -A authenticate
```
### त्रुटियों पर विफल
HTTP 4xx/5xx प्रतिक्रियाओं पर कोड 1 के साथ बाहर निकलें:
```bash
restclient -f requests.http -E
```
### आउटपुट प्रारूप
```bash
# केवल बॉडी
restclient -f requests.http -o body
# JSON पथ निष्कर्षण
restclient -f requests.http -o jsonpath "data.users[0].name"
# पर्यावरण चर प्रारूप
restclient -f requests.http -o env "token"
```
### CLI फ्लैग
| छोटा | लंबा | विवरण |
| ----- | ---- | ----------- |
| `-f` | `--file` | अनुरोध फ़ाइल पथ (आवश्यक) |
| `-n` | `--name` | नाम से अनुरोध चलाएं |
| `-i` | `--index` | इंडेक्स द्वारा अनुरोध चलाएं |
| | `--all` | फ़ाइल में सभी अनुरोध चलाएं |
| `-e` | `--expected` | अपेक्षित प्रतिक्रिया फ़ाइल |
| | `--e-name` | अपेक्षित प्रतिक्रिया नाम |
| | `--e-index` | अपेक्षित प्रतिक्रिया इंडेक्स |
| `-l` | `--list` | अनुरोध सूचीबद्ध करें |
| `-E` | `--fail-on-error` | 4xx/5xx पर विफल |
| `-o` | `--output` | आउटपुट प्रारूप |
| `-A` | `--after` | पूर्वापेक्षित अनुरोध |
| `-D` | `--define` | वेरिएबल परिभाषित करें (दोहराने योग्य) |
## प्रतिक्रिया सत्यापन
प्रतिक्रियाओं को सत्यापित करने के लिए `.hresp` फाइलें बनाएं।
**responses.hresp:**
```http
HTTP/1.1 200 OK
Content-Type: application/json
{
"id": "{{$anyGuid}}",
"name": "{{$any}}",
"createdAt": "{{$anyTimestamp}}"
}
```
**Go में सत्यापित करें:**
```go
err := client.ValidateResponses("responses.hresp", responses...)
if err != nil {
log.Fatal("सत्यापन विफल:", err)
}
```
### सत्यापन प्लेसहोल्डर्स
- `{{$any}}` - किसी भी पाठ से मेल खाता है
- `{{$regexp ``pattern``}}` - रेगेक्स पैटर्न (बैकटिक्स में)
- `{{$anyGuid}}` - UUID प्रारूप
- `{{$anyTimestamp}}` - यूनिक्स टाइमस्टैम्प
- `{{$anyDatetime 'format'}}` - दिनांक-समय (rfc1123, iso8601, या कस्टम)
## उपयोग के मामले
### मैनुअल परीक्षण
विकास के दौरान API का परीक्षण करने के लिए अपने पसंदीदा IDE एक्सटेंशन का उपयोग करें।
### स्वचालित E2E परीक्षण
```go
func TestUserAPI(t *testing.T) {
client, _ := restclient.NewClient(
restclient.WithBaseURL(testServer.URL),
)
responses, err := client.ExecuteFile(context.Background(), "user_tests.http")
require.NoError(t, err)
err = client.ValidateResponses("user_expected.hresp", responses...)
require.NoError(t, err)
}
```
## विकास
### पूर्वापेक्षाएँ
- Go 1.21+
### कमांड
```bash
make check # सभी जाँचें चलाएं (lint, test, build)
```
## लाइसेंस
MIT लाइसेंस
Comments
0 Rating appears after 10 ratings
Sign in to join the discussion.