Launchdarkly PR #2

pkg/integrations/launchdarkly/client.go

@@ -0,0 +1,134 @@
+package launchdarkly
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/superplanehq/superplane/pkg/core"
+)
+
+const defaultAPIBaseURL = "https://app.launchdarkly.com/api/v2"
+
+type Client struct {
+	Token      string
+	APIBaseURL string
+	http       core.HTTPContext
+}
+
+func NewClient(httpClient core.HTTPContext, integration core.IntegrationContext) (*Client, error) {
+	token, err := integration.GetConfig("apiAccessToken")
+	if err != nil {
+		return nil, fmt.Errorf("missing apiAccessToken: %w", err)
+	}
+
+	baseURLRaw, _ := integration.GetConfig("apiBaseUrl")
+	baseURL := resolveAPIBaseURL(string(baseURLRaw))
+
+	return &Client{
+		Token:      strings.TrimSpace(string(token)),
+		APIBaseURL: baseURL,
+		http:       httpClient,
+	}, nil
+}
+
+func resolveAPIBaseURL(configured string) string {
+	v := strings.TrimSpace(configured)
+	if v == "" {
+		return defaultAPIBaseURL
+	}
+
+	v = strings.TrimRight(v, "/")
+	if strings.HasSuffix(v, "/api/v2") {
+		return v
+	}
+
+	return v + "/api/v2"
+}
+
+func (c *Client) VerifyCredentials() error {
+	_, body, err := c.execRequestRaw(http.MethodGet, c.APIBaseURL+"/projects?limit=1")
+	if err != nil {
+		return err
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(body, &payload); err != nil {
+		return fmt.Errorf("invalid API response: %w", err)
+	}
+
+	return nil
+}
+
+func (c *Client) GetFlag(projectKey, flagKey string) (int, map[string]any, []byte, error) {
+	requestURL := fmt.Sprintf(
+		"%s/flags/%s/%s",
+		c.APIBaseURL,
+		url.PathEscape(projectKey),
+		url.PathEscape(flagKey),
+	)
+	statusCode, body, err := c.execRequestRaw(http.MethodGet, requestURL)
+	if err != nil {
+		return statusCode, nil, body, err
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(body, &payload); err != nil {
+		return statusCode, nil, body, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	return statusCode, payload, body, nil
+}
+
+func (c *Client) DeleteFlag(projectKey, flagKey string) (int, []byte, error) {
+	requestURL := fmt.Sprintf(
+		"%s/flags/%s/%s",
+		c.APIBaseURL,
+		url.PathEscape(projectKey),
+		url.PathEscape(flagKey),
+	)
+	statusCode, body, err := c.execRequestRaw(http.MethodDelete, requestURL)
+	if err != nil {
+		return statusCode, body, err
+	}
+
+	return statusCode, body, nil
+}
+
+func (c *Client) execRequestRaw(method, url string) (int, []byte, error) {
+	req, err := http.NewRequest(method, url, nil)
+	if err != nil {
+		return 0, nil, fmt.Errorf("failed to build request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", c.Token)
+
+	res, err := c.http.Do(req)
+	if err != nil {
+		return 0, nil, fmt.Errorf("request failed: %w", err)
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return res.StatusCode, nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	if res.StatusCode >= 200 && res.StatusCode < 300 {
+		return res.StatusCode, body, nil
+	}
+
+	if res.StatusCode == http.StatusUnauthorized {
+		return res.StatusCode, body, fmt.Errorf("LaunchDarkly credentials are invalid or expired")
+	}
+
+	if res.StatusCode == http.StatusForbidden {
+		return res.StatusCode, body, fmt.Errorf("LaunchDarkly token does not have required permissions")
+	}
+
+	return res.StatusCode, body, fmt.Errorf("request failed (%d): %s", res.StatusCode, string(body))
+}

pkg/integrations/launchdarkly/client_test.go

@@ -0,0 +1,83 @@
+package launchdarkly
+
+import (
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/superplanehq/superplane/test/support/contexts"
+)
+
+func Test__resolveAPIBaseURL(t *testing.T) {
+	t.Run("empty -> default US endpoint", func(t *testing.T) {
+		assert.Equal(t, "https://app.launchdarkly.com/api/v2", resolveAPIBaseURL(""))
+	})
+
+	t.Run("EU host -> appends /api/v2", func(t *testing.T) {
+		assert.Equal(t, "https://app.eu.launchdarkly.com/api/v2", resolveAPIBaseURL("https://app.eu.launchdarkly.com"))
+	})
+
+	t.Run("already has /api/v2 -> preserved", func(t *testing.T) {
+		assert.Equal(t, "https://app.eu.launchdarkly.com/api/v2", resolveAPIBaseURL("https://app.eu.launchdarkly.com/api/v2/"))
+	})
+}
+
+func Test__Client__GetFlag__encodesPathAndSendsToken(t *testing.T) {
+	httpCtx := &contexts.HTTPContext{
+		Responses: []*http.Response{
+			{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(`{"key":"my flag"}`)),
+			},
+		},
+	}
+
+	integrationCtx := &contexts.IntegrationContext{
+		Configuration: map[string]any{
+			"apiAccessToken": "token-123",
+			"apiBaseUrl":     "https://app.eu.launchdarkly.com",
+		},
+	}
+
+	client, err := NewClient(httpCtx, integrationCtx)
+	require.NoError(t, err)
+
+	statusCode, payload, _, err := client.GetFlag("my project", "my flag")
+	require.NoError(t, err)
+	assert.Equal(t, http.StatusOK, statusCode)
+	assert.Equal(t, "my flag", payload["key"])
+
+	require.Len(t, httpCtx.Requests, 1)
+	assert.Equal(t, "https://app.eu.launchdarkly.com/api/v2/flags/my%20project/my%20flag", httpCtx.Requests[0].URL.String())
+	assert.Equal(t, "token-123", httpCtx.Requests[0].Header.Get("Authorization"))
+}
+
+func Test__Client__DeleteFlag__encodesPath(t *testing.T) {
+	httpCtx := &contexts.HTTPContext{
+		Responses: []*http.Response{
+			{
+				StatusCode: http.StatusNoContent,
+				Body:       io.NopCloser(strings.NewReader("")),
+			},
+		},
+	}
+
+	integrationCtx := &contexts.IntegrationContext{
+		Configuration: map[string]any{
+			"apiAccessToken": "token-123",
+		},
+	}
+
+	client, err := NewClient(httpCtx, integrationCtx)
+	require.NoError(t, err)
+
+	statusCode, _, err := client.DeleteFlag("my project", "my flag")
+	require.NoError(t, err)
+	assert.Equal(t, http.StatusNoContent, statusCode)
+
+	require.Len(t, httpCtx.Requests, 1)
+	assert.Equal(t, "https://app.launchdarkly.com/api/v2/flags/my%20project/my%20flag", httpCtx.Requests[0].URL.String())
+}

pkg/integrations/launchdarkly/components_test.go

@@ -0,0 +1,79 @@
+package launchdarkly
+
+import (
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/superplanehq/superplane/pkg/core"
+	"github.com/superplanehq/superplane/test/support/contexts"
+)
+
+func Test__GetFlag__Execute__404HandledAsNotFound(t *testing.T) {
+	httpCtx := &contexts.HTTPContext{
+		Responses: []*http.Response{
+			{
+				StatusCode: http.StatusNotFound,
+				Body:       io.NopCloser(strings.NewReader(`{"message":"not found"}`)),
+			},
+		},
+	}
+
+	execState := &contexts.ExecutionStateContext{}
+
+	err := (&GetFlag{}).Execute(core.ExecutionContext{
+		Configuration: map[string]any{
+			"projectKey": "default",
+			"flagKey":    "missing-flag",
+		},
+		HTTP: httpCtx,
+		Integration: &contexts.IntegrationContext{Configuration: map[string]any{
+			"apiAccessToken": "token-123",
+		}},
+		ExecutionState: execState,
+	})
+
+	require.NoError(t, err)
+	assert.Equal(t, GetFlagPayloadType, execState.Type)
+	require.Len(t, execState.Payloads, 1)
+
+	payload := execState.Payloads[0].(map[string]any)["data"].(GetFlagOutput)
+	assert.False(t, payload.Found)
+	assert.Contains(t, payload.Message, "not found")
+}
+
+func Test__DeleteFlag__Execute__204Success(t *testing.T) {
+	httpCtx := &contexts.HTTPContext{
+		Responses: []*http.Response{
+			{
+				StatusCode: http.StatusNoContent,
+				Body:       io.NopCloser(strings.NewReader("")),
+			},
+		},
+	}
+
+	execState := &contexts.ExecutionStateContext{}
+
+	err := (&DeleteFlag{}).Execute(core.ExecutionContext{
+		Configuration: map[string]any{
+			"projectKey": "default",
+			"flagKey":    "my-flag",
+		},
+		HTTP: httpCtx,
+		Integration: &contexts.IntegrationContext{Configuration: map[string]any{
+			"apiAccessToken": "token-123",
+		}},
+		ExecutionState: execState,
+	})
+
+	require.NoError(t, err)
+	assert.Equal(t, DeleteFlagPayloadType, execState.Type)
+	require.Len(t, execState.Payloads, 1)
+
+	payload := execState.Payloads[0].(map[string]any)["data"].(DeleteFlagOutput)
+	assert.True(t, payload.Deleted)
+	assert.Equal(t, http.StatusNoContent, payload.StatusCode)
+}