withttp

Example_fasthttp_basicCall demonstrates how to make a simple HTTP call using the FastHTTP adapter.

type RepoInfo struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

// Create a mocked endpoint for the example
endpoint := NewEndpoint("GithubAPI").
	Request(BaseURL("https://api.github.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(`{"id": 12345, "name": "withttp"}`)))
			res.SetStatus(http.StatusOK)
		}),
	)

call := NewCall[RepoInfo](NewMockHttpClientAdapter()).
	URI("/repos/user/repo").
	Method(http.MethodGet).
	Header("User-Agent", "withttp-example", false).
	ParseJSON().
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), endpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Printf("Repo ID: %d, Name: %s\n", call.BodyParsed.ID, call.BodyParsed.Name)

Output:
Repo ID: 12345, Name: withttp

Example_fasthttp_postRequest demonstrates how to make a POST request with JSON body using FastHTTP.

type CreateRequest struct {
	Title string `json:"title"`
	Body  string `json:"body"`
}

type CreateResponse struct {
	ID  int    `json:"id"`
	URL string `json:"url"`
}

// Create a mocked endpoint for the example
endpoint := NewEndpoint("API").
	Request(BaseURL("https://api.example.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(
				io.NopCloser(
					strings.NewReader(`{"id": 42, "url": "https://api.example.com/items/42"}`),
				),
			)
			res.SetStatus(http.StatusCreated)
		}),
	)

payload := CreateRequest{
	Title: "Example Item",
	Body:  "This is an example",
}

call := NewCall[CreateResponse](NewMockHttpClientAdapter()).
	URI("/items").
	Method(http.MethodPost).
	ContentType(ContentTypeJSON).
	Body(payload).
	Header("Authorization", "Bearer token", true).
	ParseJSON().
	ExpectedStatusCodes(http.StatusCreated)

err := call.CallEndpoint(context.Background(), endpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Printf("Created item ID: %d\n", call.BodyParsed.ID)

Output:
Created item ID: 42

Example_fasthttp_withHeaderFunc demonstrates using header functions with FastHTTP.

type APIResponse struct {
	Message string `json:"message"`
}

endpoint := NewEndpoint("API").
	Request(BaseURL("https://api.example.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(`{"message": "Hello"}`)))
			res.SetStatus(http.StatusOK)
		}),
	)

call := NewCall[APIResponse](NewMockHttpClientAdapter()).
	URI("/hello").
	Method(http.MethodGet).
	HeaderFunc(func() (key, value string, override bool) {
		key = "X-Timestamp"
		value = "2025-06-29T12:00:00Z"
		override = true
		return
	}).
	HeaderFunc(func() (key, value string, override bool) {
		key = "X-Request-ID"
		value = "req-12345"
		override = true
		return
	}).
	ParseJSON().
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), endpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Printf("Response: %s\n", call.BodyParsed.Message)

Output:
Response: Hello

Example_mockEndpoint demonstrates how to create and use a mocked endpoint for testing.

type Order struct {
	Amount float64 `json:"amount"`
	Pair   string  `json:"pair"`
}

// Create a mocked endpoint that returns test data
mockEndpoint := NewEndpoint("MockExchange").
	Request(BaseURL("http://example.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(`{"amount": 100.5, "pair": "BTC/USD"}`)))
			res.SetStatus(http.StatusOK)
		}),
	)

call := NewCall[Order](NewMockHttpClientAdapter()).
	Method(http.MethodGet).
	Header("Authorization", "Bearer token123", true).
	ParseJSON().
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), mockEndpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Printf("Order amount: %.1f, Pair: %s\n", call.BodyParsed.Amount, call.BodyParsed.Pair)

Output:
Order amount: 100.5, Pair: BTC/USD

Example_parseCSV demonstrates parsing CSV response data.

type Repository struct {
	Rank  int
	Name  string
	Stars int
}

csvData := `rank,name,stars
1,awesome-go,75000
2,gin,65000`

endpoint := NewEndpoint("RepoStats").
	Request(BaseURL("https://api.example.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(csvData)))
			res.SetStatus(http.StatusOK)
		}),
	)

parser := csvparser.New[Repository](
	csvparser.SeparatorComma,
	csvparser.IntCol[Repository](
		csvparser.QuoteNone,
		nil,
		func(x *Repository, rank int) { x.Rank = rank },
	),
	csvparser.StringCol[Repository](
		csvparser.QuoteNone,
		nil,
		func(x *Repository, name string) { x.Name = name },
	),
	csvparser.IntCol[Repository](
		csvparser.QuoteNone,
		nil,
		func(x *Repository, stars int) { x.Stars = stars },
	),
)

call := NewCall[Repository](NewMockHttpClientAdapter()).
	URI("/top-repos.csv").
	Method(http.MethodGet).
	ParseCSV(1, parser, func(repo Repository) bool { // skip 1 header line
		fmt.Printf("Rank %d: %s (%d stars)\n", repo.Rank, repo.Name, repo.Stars)
		return true // continue processing
	}).
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), endpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Output:
Rank 1: awesome-go (75000 stars)
Rank 2: gin (65000 stars)

Example_parseJSONEachRow demonstrates parsing JSON-each-row format responses.

type Trade struct {
	Price  float64 `json:"price"`
	Volume float64 `json:"volume"`
}

mockData := `{"price": 50000.0, "volume": 1.5}
{"price": 51000.0, "volume": 0.8}`

mockEndpoint := NewEndpoint("TradesAPI").
	Request(BaseURL("http://example.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(mockData)))
			res.SetStatus(http.StatusOK)
		}),
	)

var trades []Trade
call := NewCall[Trade](NewMockHttpClientAdapter()).
	Method(http.MethodGet).
	ParseJSONEachRow(func(trade Trade) bool {
		trades = append(trades, trade)
		return true // continue processing
	}).
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), mockEndpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Printf("Processed %d trades\n", len(trades))
if len(trades) > 0 {
	fmt.Printf("First trade: $%.0f, volume: %.1f\n", trades[0].Price, trades[0].Volume)
}

Output:
Processed 2 trades
First trade: $50000, volume: 1.5

Example_requestStream_fromSlice demonstrates streaming data from a slice to the server.

type DataPoint struct {
	Timestamp int64   `json:"ts"`
	Value     float64 `json:"val"`
}

// Sample data to stream
data := []DataPoint{
	{Timestamp: 1672531200, Value: 25.5},
	{Timestamp: 1672531260, Value: 26.1},
	{Timestamp: 1672531320, Value: 24.8},
}

stream := Slice[DataPoint](data)

mockEndpoint := NewEndpoint("DataIngestion").
	Request(BaseURL("https://api.example.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(`{"status": "received"}`)))
			res.SetStatus(http.StatusOK)
		}),
	)

call := NewCall[any](NewMockHttpClientAdapter()).
	URI("/data").
	Method(http.MethodPost).
	ContentType(ContentTypeJSONEachRow).
	RequestStreamBody(
		RequestStreamBody[any, DataPoint](stream),
	).
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), mockEndpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Println("Data streamed successfully")

Output:
Data streamed successfully

Example_requestStream_withSniffer demonstrates streaming with request sniffing.

type Event struct {
	Type string `json:"type"`
}

events := []Event{
	{Type: "click"},
	{Type: "view"},
}

stream := Slice[Event](events)

mockEndpoint := NewEndpoint("Analytics").
	Request(BaseURL("https://api.example.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(`{"processed": true}`)))
			res.SetStatus(http.StatusOK)
		}),
	)

call := NewCall[any](NewMockHttpClientAdapter()).
	URI("/events").
	Method(http.MethodPost).
	ContentType(ContentTypeJSONEachRow).
	RequestSniffed(func(data []byte, err error) {
		if err == nil {
			// Simplify output to avoid JSON formatting issues
			if strings.Contains(string(data), "click") {
				fmt.Println("Sending click event")
			} else if strings.Contains(string(data), "view") {
				fmt.Println("Sending view event")
			}
		}
	}).
	RequestStreamBody(
		RequestStreamBody[any, Event](stream),
	).
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), mockEndpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Println("Events processed")

Output:
Sending click event
Sending view event
Events processed

Example_singleCall demonstrates making a simple HTTP GET request.

type RepoInfo struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

// Create a mocked endpoint for the example
endpoint := NewEndpoint("GithubAPI").
	Request(BaseURL("https://api.github.com")).
	Response(
		MockedRes(func(res Response) {
			res.SetBody(io.NopCloser(strings.NewReader(`{"id": 12345, "name": "withttp"}`)))
			res.SetStatus(http.StatusOK)
		}),
	)

call := NewCall[RepoInfo](NewMockHttpClientAdapter()).
	URI("/repos/user/repo").
	Method(http.MethodGet).
	Header("User-Agent", "withttp-example", false).
	ParseJSON().
	ExpectedStatusCodes(http.StatusOK)

err := call.CallEndpoint(context.Background(), endpoint)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

fmt.Printf("Repo ID: %d, Name: %s\n", call.BodyParsed.ID, call.BodyParsed.Name)

Output:
Repo ID: 12345, Name: withttp

Example_singleCall_directURL demonstrates making a request directly to a URL without an endpoint.

type SimpleResponse struct {
	Status string `json:"status"`
}

// For this example, we'll simulate a call but skip it in practice
// In real usage, you would just call without the skip
call := NewCall[SimpleResponse](NetHttp()).
	URL("https://httpbin.org/json").
	Method(http.MethodGet).
	Header("User-Agent", "withttp-example", false).
	ParseJSON().
	ExpectedStatusCodes(http.StatusOK)

// For documentation purposes, we'll show what the call would look like
_ = call // Normally: err := call.Call(context.Background())

fmt.Println("This would make a direct HTTP call to the specified URL")

Output:
This would make a direct HTTP call to the specified URL