api_client: create generate method

Author: aviau

api_client.go

@@ -1,27 +1,98 @@
 package flareio
 
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
 type ApiClient struct {
-	tenantId int
-	apiKey   string
+	tenantId   int
+	apiKey     string
+	httpClient *http.Client
+	baseUrl    string
 }
 
 type ApiClientOption func(*ApiClient)
 
+// WithTenantId allows configuring the tenant id.
 func WithTenantId(tenantId int) ApiClientOption {
 	return func(client *ApiClient) {
 		client.tenantId = tenantId
 	}
 }
 
+// withBaseUrl allows configuring the base url, for testing only.
+func withBaseUrl(baseUrl string) ApiClientOption {
+	return func(client *ApiClient) {
+		client.baseUrl = baseUrl
+	}
+}
+
 func NewClient(
 	apiKey string,
 	optionFns ...ApiClientOption,
 ) *ApiClient {
 	c := &ApiClient{
-		apiKey: apiKey,
+		apiKey:     apiKey,
+		baseUrl:    "https://api.flare.io/",
+		httpClient: &http.Client{},
 	}
 	for _, optionFn := range optionFns {
 		optionFn(c)
 	}
 	return c
 }
+
+func (client *ApiClient) GenerateToken() (string, error) {
+	// Prepare payload
+	type GeneratePayload struct {
+		TenantId int `json:"tenant_id,omitempty"`
+	}
+	payload := &GeneratePayload{
+		TenantId: client.tenantId,
+	}
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal generate payload: %w", err)
+	}
+
+	// Create dest URL
+	destUrl, err := url.JoinPath(client.baseUrl, "/tokens/generate")
+	if err != nil {
+		return "", fmt.Errorf("failed to create test URL: %w", err)
+	}
+
+	// Prepare the request
+	request, err := http.NewRequest(
+		"POST",
+		destUrl,
+		bytes.NewReader(payloadBytes),
+	)
+	if err != nil {
+		return "", fmt.Errorf("failed to prepare request: %w", err)
+	}
+	request.Header.Set("Authorization", client.apiKey)
+
+	// Fire the request
+	resp, err := client.httpClient.Do(request)
+	if err != nil {
+		return "", fmt.Errorf("failed to generate API token: %w", err)
+	}
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("unexpected response code: %d", resp.StatusCode)
+	}
+
+	// Parse response
+	type TokenResponse struct {
+		Token string `json:"token"`
+	}
+	var tokenResponse TokenResponse
+	if err := json.NewDecoder(resp.Body).Decode(&tokenResponse); err != nil {
+		return "", err
+	}
+
+	return tokenResponse.Token, nil
+}

api_client_http_test.go

@@ -0,0 +1,51 @@
+package flareio
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type ClientTest struct {
+	apiClient  *ApiClient
+	httpServer *httptest.Server
+}
+
+func newClientTest(
+	handler http.HandlerFunc,
+) *ClientTest {
+	httpServer := httptest.NewServer(
+		handler,
+	)
+	apiClient := NewClient(
+		"test-api-key",
+		withBaseUrl(httpServer.URL),
+	)
+	clientTest := &ClientTest{
+		httpServer: httpServer,
+		apiClient:  apiClient,
+	}
+	return clientTest
+}
+
+func (clientTest *ClientTest) Close() {
+	defer clientTest.httpServer.Close()
+}
+
+func TestGenerateToken(t *testing.T) {
+	clientTest := newClientTest(
+		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			assert.Equal(t, "/tokens/generate", r.URL.Path)
+			assert.Equal(t, []string{"test-api-key"}, r.Header["Authorization"])
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`{"token":"test-token-hello"}`))
+		}),
+	)
+	defer clientTest.Close()
+
+	token, err := clientTest.apiClient.GenerateToken()
+	assert.NoError(t, err, "Generating a token")
+	assert.Equal(t, "test-token-hello", token)
+}

api_client_initialize_test.go

@@ -0,0 +1,31 @@
+package flareio
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateClientWithApiKey(t *testing.T) {
+	c := NewClient("test-api-key")
+	assert.Equal(t, "test-api-key", c.apiKey)
+	assert.Equal(t, 0, c.tenantId)
+	assert.Equal(t, "https://api.flare.io/", c.baseUrl)
+}
+
+func TestCreateClientWithTenantId(t *testing.T) {
+	c := NewClient(
+		"test-api-key",
+		WithTenantId(42),
+	)
+	assert.Equal(t, "test-api-key", c.apiKey)
+	assert.Equal(t, 42, c.tenantId)
+}
+
+func TestCreateClientWithBaseUrl(t *testing.T) {
+	c := NewClient(
+		"test-api-key",
+		withBaseUrl("https://test.com/"),
+	)
+	assert.Equal(t, "https://test.com/", c.baseUrl)
+}