wip: filters client

Author: paulrosca-snyk

.gitignore

@@ -4,5 +4,6 @@
 ### Local development ###
 # Local build system configuration
 /local.mk
+.idea
 
 node_modules

internal/fileupload/filters/client.go

@@ -0,0 +1,71 @@
+package filters
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/google/uuid"
+)
+
+// AllowList represents the response structure from the deeproxy filters API.
+type AllowList struct {
+	ConfigFiles []string `json:"configFiles"`
+	Extensions  []string `json:"extensions"`
+}
+
+type Client interface {
+	GetFilters(ctx context.Context, orgID uuid.UUID) (AllowList, error)
+}
+
+type deeproxyClient struct {
+	httpClient *http.Client
+	cfg        Config
+}
+
+type Config struct {
+	BaseURL   string
+	IsFedRamp bool
+}
+
+func NewDeeproxyClient(cfg Config, opts ...Opt) *deeproxyClient {
+	c := &deeproxyClient{
+		cfg:        cfg,
+		httpClient: http.DefaultClient,
+	}
+
+	for _, opt := range opts {
+		opt(c)
+	}
+
+	return c
+}
+
+func (c *deeproxyClient) GetFilters(ctx context.Context, orgID uuid.UUID) (AllowList, error) {
+	var allowList AllowList
+
+	url := getFilterUrl(c.cfg.BaseURL, orgID, c.cfg.IsFedRamp)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, http.NoBody)
+	if err != nil {
+		return allowList, fmt.Errorf("failed to create deeproxy filters request: %w", err)
+	}
+
+	req.Header.Set("snyk-org-name", orgID.String())
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return allowList, fmt.Errorf("error making deeproxy filters request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		return allowList, fmt.Errorf("unexpected response code: %s", resp.Status)
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&allowList); err != nil {
+		return allowList, fmt.Errorf("failed to decode deeproxy filters response: %w", err)
+	}
+
+	return allowList, nil
+}

internal/fileupload/filters/client_test.go

@@ -0,0 +1,77 @@
+package filters
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClients(t *testing.T) {
+	tests := []struct {
+		getClient  func(t *testing.T, orgID uuid.UUID, expectedAllow AllowList) (Client, func())
+		clientName string
+	}{
+		{
+			clientName: "deeproxyClient",
+			getClient: func(t *testing.T, orgID uuid.UUID, expectedAllow AllowList) (Client, func()) {
+				t.Helper()
+
+				s := setupServer(t, orgID, expectedAllow)
+				cleanup := func() {
+					s.Close()
+				}
+				c := NewDeeproxyClient(Config{BaseURL: s.URL, IsFedRamp: true}, WithHTTPClient(s.Client()))
+
+				return c, cleanup
+			},
+		},
+		{
+			clientName: "fakeClient",
+			getClient: func(t *testing.T, orgID uuid.UUID, expectedAllow AllowList) (Client, func()) {
+				t.Helper()
+
+				c := NewFakeClient(expectedAllow, nil)
+
+				return c, func() {}
+			},
+		},
+	}
+
+	for _, testData := range tests {
+		t.Run(testData.clientName+": GetFilters", func(t *testing.T) {
+			orgID := uuid.New()
+			expectedAllow := AllowList{
+				ConfigFiles: []string{"package.json"},
+				Extensions:  []string{".ts", ".js"},
+			}
+			client, cleanup := testData.getClient(t, orgID, expectedAllow)
+			defer cleanup()
+
+			allow, err := client.GetFilters(t.Context(), orgID)
+			require.NoError(t, err)
+
+			assert.Equal(t, expectedAllow, allow)
+		})
+	}
+}
+
+func setupServer(t *testing.T, orgID uuid.UUID, expectedAllow AllowList) *httptest.Server {
+	t.Helper()
+	ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		expectedURL := getFilterUrl("", orgID, true)
+		assert.Equal(t, expectedURL, r.URL.Path)
+		assert.Equal(t, orgID.String(), r.Header.Get("snyk-org-name"))
+		w.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(w).Encode(expectedAllow); err != nil {
+			http.Error(w, "failed to encode response", http.StatusInternalServerError)
+			return
+		}
+	}))
+	ts.Start()
+	return ts
+}

internal/fileupload/filters/fake_client.go

@@ -0,0 +1,23 @@
+package filters
+
+import (
+	"context"
+	"github.com/google/uuid"
+)
+
+type fakeClient struct {
+	getFilters func(ctx context.Context, orgID uuid.UUID) (AllowList, error)
+}
+
+func NewFakeClient(allowList AllowList, err error) Client {
+	return &fakeClient{
+		getFilters: func(ctx context.Context, orgID uuid.UUID) (AllowList, error) {
+			return allowList, err
+		},
+	}
+
+}
+
+func (f *fakeClient) GetFilters(ctx context.Context, orgID uuid.UUID) (AllowList, error) {
+	return f.getFilters(ctx, orgID)
+}

internal/fileupload/filters/opts.go

@@ -0,0 +1,13 @@
+package filters
+
+import "net/http"
+
+// Opt is a function that configures an deeproxyClient instance.
+type Opt func(*deeproxyClient)
+
+// WithHTTPClient sets a custom HTTP client for the filters client.
+func WithHTTPClient(httpClient *http.Client) Opt {
+	return func(c *deeproxyClient) {
+		c.httpClient = httpClient
+	}
+}

internal/fileupload/filters/utils.go

@@ -0,0 +1,17 @@
+package filters
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/google/uuid"
+)
+
+func getFilterUrl(baseUrl string, orgID uuid.UUID, isFedRamp bool) string {
+	if isFedRamp {
+		return fmt.Sprintf("%s/hidden/orgs/%s/code/filters", baseUrl, orgID)
+	} else {
+		deeproxyUrl := strings.ReplaceAll(baseUrl, "api", "deeproxy")
+		return fmt.Sprintf("%s/filters", deeproxyUrl)
+	}
+}

internal/fileupload/filters/utils_test.go

@@ -0,0 +1,19 @@
+package filters
+
+import (
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+var orgId = uuid.MustParse("738ef92e-21cc-4a11-8c13-388d89272f4b")
+
+func Test_getBaseUrl_notFedramp(t *testing.T) {
+	actualUrl := getFilterUrl("https://api.snyk.io", orgId, false)
+	assert.Equal(t, "https://deeproxy.snyk.io/filters", actualUrl)
+}
+
+func Test_getBaseUrl_fedramp(t *testing.T) {
+	actualUrl := getFilterUrl("https://api.snyk.io", orgId, true)
+	assert.Equal(t, "https://api.snyk.io/hidden/orgs/738ef92e-21cc-4a11-8c13-388d89272f4b/code/filters", actualUrl)
+}

internal/fileupload/types.go

@@ -22,12 +22,6 @@ type Filters struct {
 	initErr              error
 }
 
-// FiltersResponse represents the response structure from the deeproxy filters API.
-type FiltersResponse struct {
-	ConfigFiles []string `json:"configFiles"`
-	Extensions  []string `json:"extensions"`
-}
-
 // UploadOptions configures the behavior of file upload operations.
 type UploadOptions struct {
 	SkipFiltering bool