feat: new deepcode LLM binding [IDE-877] (#74)

Co-authored-by: Abdelrahman Shawki Hassan <[email protected]>

Author: bastiandoetsch

http/http.go

@@ -153,3 +153,8 @@ func (s *httpClient) httpCall(req *http.Request) (*http.Response, error) {
 
 	return response, nil
 }
+
+func NewDefaultClientFactory() HTTPClientFactory {
+	clientFunc := func() *http.Client { return http.DefaultClient }
+	return clientFunc
+}

llm/api_client.go

@@ -0,0 +1,115 @@
+package llm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/url"
+
+	"github.com/snyk/code-client-go/observability"
+)
+
+const (
+	completeStatus                = "COMPLETE"
+	failedToObtainRequestIdString = "Failed to obtain request id. "
+	defaultEndpointURL            = "http://localhost:10000/explain"
+)
+
+func (d *DeepcodeLLMBinding) runExplain(ctx context.Context, options ExplainOptions) (explainResponse, error) {
+	span := d.instrumentor.StartSpan(ctx, "code.RunExplain")
+	defer span.Finish()
+
+	requestId, err := observability.GetTraceId(ctx)
+	logger := d.logger.With().Str("method", "code.RunExplain").Str("requestId", requestId).Logger()
+	if err != nil {
+		logger.Err(err).Msg(failedToObtainRequestIdString + err.Error())
+		return explainResponse{}, err
+	}
+
+	logger.Debug().Msg("API: Retrieving explain for bundle")
+	defer logger.Debug().Msg("API: Retrieving explain done")
+
+	requestBody, err := d.explainRequestBody(&options)
+	if err != nil {
+		logger.Err(err).Str("requestBody", string(requestBody)).Msg("error creating request body")
+		return explainResponse{}, err
+	}
+	logger.Debug().Str("payload body: %s\n", string(requestBody)).Msg("Marshaled payload")
+
+	u := d.endpoint
+	if u == nil {
+		u, err = url.Parse(defaultEndpointURL)
+		if err != nil {
+			logger.Err(err).Send()
+			return explainResponse{}, err
+		}
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), bytes.NewBuffer(requestBody))
+	if err != nil {
+		logger.Err(err).Str("requestBody", string(requestBody)).Msg("error creating request")
+		return explainResponse{}, err
+	}
+
+	d.addDefaultHeaders(req, requestId)
+
+	resp, err := d.httpClientFunc().Do(req) //nolint:bodyclose // this seems to be a false positive
+	if err != nil {
+		logger.Err(err).Str("requestBody", string(requestBody)).Msg("error getting response")
+		return explainResponse{}, err
+	}
+	defer func(Body io.ReadCloser) {
+		bodyCloseErr := Body.Close()
+		if bodyCloseErr != nil {
+			logger.Err(err).Str("requestBody", string(requestBody)).Msg("error closing response")
+		}
+	}(resp.Body)
+
+	// Read the response body
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		logger.Err(err).Str("requestBody", string(requestBody)).Msg("error reading all response")
+		return explainResponse{}, err
+	}
+	logger.Debug().Str("response body: %s\n", string(responseBody)).Msg("Got the response")
+
+	var response explainResponse
+	response.Status = completeStatus
+	err = json.Unmarshal(responseBody, &response)
+	if err != nil {
+		logger.Err(err).Str("responseBody", string(responseBody)).Msg("error unmarshalling")
+		return explainResponse{}, err
+	}
+	return response, nil
+}
+
+func (d *DeepcodeLLMBinding) explainRequestBody(options *ExplainOptions) ([]byte, error) {
+	logger := d.logger.With().Str("method", "code.explainRequestBody").Logger()
+
+	var request explainRequest
+	if options.Diff == "" {
+		request.VulnExplanation = &explainVulnerabilityRequest{
+			RuleId:            options.RuleKey,
+			Derivation:        options.Derivation,
+			RuleMessage:       options.RuleMessage,
+			ExplanationLength: SHORT,
+		}
+		logger.Debug().Msg("payload for VulnExplanation")
+	} else {
+		request.FixExplanation = &explainFixRequest{
+			RuleId:            options.RuleKey,
+			Diff:              options.Diff,
+			ExplanationLength: SHORT,
+		}
+		logger.Debug().Msg("payload for FixExplanation")
+	}
+	requestBody, err := json.Marshal(request)
+	return requestBody, err
+}
+
+func (d *DeepcodeLLMBinding) addDefaultHeaders(req *http.Request, requestId string) {
+	req.Header.Set("snyk-request-id", requestId)
+	req.Header.Set("Cache-Control", "private, max-age=0, no-cache")
+	req.Header.Set("Content-Type", "application/json")
+}

llm/api_client_test.go

@@ -0,0 +1,201 @@
+package llm
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/snyk/code-client-go/observability"
+)
+
+func TestDeepcodeLLMBinding_runExplain(t *testing.T) {
+	tests := []struct {
+		name               string
+		options            ExplainOptions
+		serverResponse     string
+		serverStatusCode   int
+		expectedResponse   explainResponse
+		expectedError      string
+		expectedLogMessage string
+	}{
+		{
+			name: "successful vuln explanation",
+			options: ExplainOptions{
+				RuleKey:     "rule-key",
+				Derivation:  "Derivation",
+				RuleMessage: "rule-message",
+			},
+			serverResponse:   `{"explanation": "This is a vulnerability explanation"}`,
+			serverStatusCode: http.StatusOK,
+			expectedResponse: explainResponse{
+				Status:      completeStatus,
+				Explanation: "This is a vulnerability explanation",
+			},
+		},
+		{
+			name: "successful fix explanation",
+			options: ExplainOptions{
+				RuleKey: "rule-key",
+				Diff:    "Diff",
+			},
+			serverResponse:   `{"explanation": "This is a fix explanation"}`,
+			serverStatusCode: http.StatusOK,
+			expectedResponse: explainResponse{
+				Status:      completeStatus,
+				Explanation: "This is a fix explanation",
+			},
+		},
+		{
+			name:               "error creating request body",
+			options:            ExplainOptions{}, // Missing required fields will cause an error
+			serverStatusCode:   http.StatusUnprocessableEntity,
+			expectedError:      "unexpected end of JSON input",
+			expectedLogMessage: "error creating request body",
+		},
+		{
+			name: "error getting response",
+			options: ExplainOptions{
+				RuleKey:     "rule-key",
+				Derivation:  "Derivation",
+				RuleMessage: "rule-message",
+			},
+			serverStatusCode:   http.StatusInternalServerError,
+			expectedError:      "unexpected end of JSON input",
+			expectedLogMessage: "error getting response",
+		},
+		{
+			name: "error unmarshalling response",
+			options: ExplainOptions{
+				RuleKey:     "rule-key",
+				Derivation:  "Derivation",
+				RuleMessage: "rule-message",
+			},
+			serverResponse:     `invalid json`,
+			serverStatusCode:   http.StatusOK,
+			expectedError:      "invalid character 'i' looking for beginning of value",
+			expectedLogMessage: "error unmarshalling",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(tt.serverStatusCode)
+				_, _ = w.Write([]byte(tt.serverResponse))
+				if tt.expectedError == "unexpected EOF" {
+					_ = r.Body.Close() // Close the request body early to simulate a read error
+				}
+			}))
+			defer server.Close()
+
+			u, err := url.Parse(server.URL)
+			assert.NoError(t, err)
+
+			d := NewDeepcodeLLMBinding(WithEndpoint(u))
+
+			ctx := context.Background()
+			ctx = observability.GetContextWithTraceId(ctx, "test-trace-id")
+
+			response, err := d.runExplain(ctx, tt.options)
+
+			if tt.expectedError != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.expectedError)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expectedResponse, response)
+			}
+		})
+	}
+}
+
+func TestDeepcodeLLMBinding_explainRequestBody(t *testing.T) {
+	d := &DeepcodeLLMBinding{
+		logger: testLogger(t),
+	}
+
+	t.Run("VulnExplanation", func(t *testing.T) {
+		options := &ExplainOptions{
+			RuleKey:     "test-rule-key",
+			Derivation:  "test-Derivation",
+			RuleMessage: "test-rule-message",
+		}
+		requestBody, err := d.explainRequestBody(options)
+		require.NoError(t, err)
+
+		var request explainRequest
+		err = json.Unmarshal(requestBody, &request)
+		require.NoError(t, err)
+
+		assert.Nil(t, request.FixExplanation)
+		assert.NotNil(t, request.VulnExplanation)
+		assert.Equal(t, "test-rule-key", request.VulnExplanation.RuleId)
+		assert.Equal(t, "test-Derivation", request.VulnExplanation.Derivation)
+		assert.Equal(t, "test-rule-message", request.VulnExplanation.RuleMessage)
+		assert.Equal(t, SHORT, request.VulnExplanation.ExplanationLength)
+	})
+
+	t.Run("FixExplanation", func(t *testing.T) {
+		options := &ExplainOptions{
+			RuleKey: "test-rule-key",
+			Diff:    "test-Diff",
+		}
+		requestBody, err := d.explainRequestBody(options)
+		require.NoError(t, err)
+
+		var request explainRequest
+		err = json.Unmarshal(requestBody, &request)
+		require.NoError(t, err)
+
+		assert.Nil(t, request.VulnExplanation)
+		assert.NotNil(t, request.FixExplanation)
+		assert.Equal(t, "test-rule-key", request.FixExplanation.RuleId)
+		assert.Equal(t, "test-Diff", request.FixExplanation.Diff)
+		assert.Equal(t, SHORT, request.FixExplanation.ExplanationLength)
+	})
+}
+
+// Helper function for testing
+func testLogger(t *testing.T) *zerolog.Logger {
+	t.Helper()
+	logger := zerolog.New(io.Discard)
+	return &logger
+}
+
+// Test with existing headers
+func TestAddDefaultHeadersWithExistingHeaders(t *testing.T) {
+	d := &DeepcodeLLMBinding{} // Initialize your struct if needed
+	req := &http.Request{Header: http.Header{"Existing-Header": {"existing-value"}}}
+	requestId := "test-request-id"
+
+	d.addDefaultHeaders(req, requestId)
+
+	snykRequestId := req.Header.Get("snyk-request-id")
+	cacheControl := req.Header.Get("Cache-Control")
+	contentType := req.Header.Get("Content-Type")
+	existingHeader := req.Header.Get("Existing-Header")
+
+	if snykRequestId != requestId {
+		t.Errorf("Expected snyk-request-id header to be %s, got %s", requestId, snykRequestId)
+	}
+
+	if cacheControl != "private, max-age=0, no-cache" {
+		t.Errorf("Expected Cache-Control header to be 'private, max-age=0, no-cache', got %s", cacheControl)
+	}
+
+	if contentType != "application/json" {
+		t.Errorf("Expected Content-Type header to be 'application/json', got %s", contentType)
+	}
+
+	if existingHeader != "existing-value" {
+		t.Errorf("Expected Existing-Header to be 'existing-value', got %s", existingHeader)
+	}
+}