Git Integration POST Request (#1272)

* added git integration post request

* added function to XscService interface

* added SendGitIntegrationEvent to xsc inner service

* after cr

Author: orto17

tests/xscanalyticsevent_test.go

@@ -4,15 +4,17 @@ package tests
 
 import (
 	"encoding/json"
-	"github.com/jfrog/jfrog-client-go/http/jfroghttpclient"
-	"github.com/jfrog/jfrog-client-go/xsc/services"
-	"github.com/jfrog/jfrog-client-go/xsc/services/utils"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/jfrog/jfrog-client-go/http/jfroghttpclient"
+	"github.com/jfrog/jfrog-client-go/xsc/services"
+	"github.com/jfrog/jfrog-client-go/xsc/services/utils"
 )
 
 const TestMultiScanId = "3472b4e2-bddc-11ee-a9c9-acde48001122"
@@ -137,3 +139,91 @@ func createXscMockServerForGeneralEvent(t *testing.T) (mockServer *httptest.Serv
 	analyticsService.XrayDetails = xrayDetails
 	return
 }
+
+func TestXscSendGitIntegrationEvent(t *testing.T) {
+	initXscTest(t, services.LogErrorMinXscVersion, utils.MinXrayVersionGitIntegrationEvent)
+
+	testCases := []struct {
+		name        string
+		xrayVersion string
+		expectError bool
+		errorMsg    string
+	}{
+		{
+			name:        "Xray version below minimum",
+			xrayVersion: "3.134.0",
+			expectError: true,
+			errorMsg:    "git integration event requires minimum Xray version",
+		},
+		{
+			name:        "Xray version at minimum",
+			xrayVersion: "3.135.0",
+			expectError: false,
+		},
+		{
+			name:        "Xray version above minimum",
+			xrayVersion: "3.136.0",
+			expectError: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			mockServer, analyticsService := createXscMockServerForGitIntegrationEvent(t)
+			defer mockServer.Close()
+
+			event := services.GitIntegrationEvent{
+				EventType:     "Source Code SBOM Results Upload",
+				GitProvider:   "github",
+				GitOwner:      "jfrog",
+				GitRepository: "jfrog-cli-security",
+				GitBranch:     "main",
+				EventStatus:   "completed",
+			}
+
+			err := analyticsService.SendGitIntegrationEvent(event, tc.xrayVersion)
+
+			if tc.expectError {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), tc.errorMsg)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func createXscMockServerForGitIntegrationEvent(t *testing.T) (mockServer *httptest.Server, analyticsService *services.AnalyticsEventService) {
+	mockServer = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.Contains(r.RequestURI, "/xray/api/v1/xsc/git_integration_event") && r.Method == http.MethodPost:
+			// Validate request body
+			var receivedEvent services.GitIntegrationEvent
+			err := json.NewDecoder(r.Body).Decode(&receivedEvent)
+			assert.NoError(t, err)
+
+			// Validate required fields
+			assert.NotEmpty(t, receivedEvent.EventType)
+			assert.NotEmpty(t, receivedEvent.GitProvider)
+			assert.NotEmpty(t, receivedEvent.GitOwner)
+			assert.NotEmpty(t, receivedEvent.GitRepository)
+			assert.NotEmpty(t, receivedEvent.GitBranch)
+			assert.NotEmpty(t, receivedEvent.EventStatus)
+
+			w.WriteHeader(http.StatusCreated)
+		default:
+			assert.Fail(t, "received an unexpected request: "+r.Method+" "+r.RequestURI)
+		}
+	}))
+
+	xrayDetails := GetXrayDetails()
+	xrayDetails.SetUrl(mockServer.URL + "/xray")
+	xrayDetails.SetAccessToken("")
+
+	client, err := jfroghttpclient.JfrogClientBuilder().Build()
+	assert.NoError(t, err)
+
+	analyticsService = services.NewAnalyticsEventService(client)
+	analyticsService.XrayDetails = xrayDetails
+	return
+}

xray/services/xsc/xsc.go

@@ -32,6 +32,13 @@ func (xs *XscInnerService) AddAnalyticsGeneralEvent(event services.XscAnalyticsG
 	return eventService.AddGeneralEvent(event, xrayVersion)
 }
 
+func (xs *XscInnerService) SendGitIntegrationEvent(event services.GitIntegrationEvent, xrayVersion string) error {
+	eventService := services.NewAnalyticsEventService(xs.client)
+	eventService.XrayDetails = xs.XrayDetails
+	eventService.ScopeProjectKey = xs.ScopeProjectKey
+	return eventService.SendGitIntegrationEvent(event, xrayVersion)
+}
+
 func (xs *XscInnerService) SendXscLogErrorRequest(errorLog *services.ExternalErrorLog) error {
 	logErrorService := services.NewLogErrorEventService(xs.client)
 	logErrorService.XrayDetails = xs.XrayDetails

xsc/manager.go

@@ -87,3 +87,9 @@ func (sm *XscServicesManager) GetConfigProfileByUrl(_ string) (*services.ConfigP
 	// Empty implementation required for alignment with interface, implemented only at the new service inside the Xray service
 	return nil, nil
 }
+
+// SendGitIntegrationEvent sends a git integration event to xray
+func (sm *XscServicesManager) SendGitIntegrationEvent(event services.GitIntegrationEvent, xrayVersion string) error {
+	// Empty implementation required for alignment with interface, implemented only at the new service inside the Xray service
+	return nil
+}

xsc/service.go

@@ -19,4 +19,6 @@ type XscService interface {
 	GetConfigProfileByName(profileName string) (*services.ConfigProfile, error)
 	// GetConfigProfileByUrl returns the configuration profile related to the provided repository url.
 	GetConfigProfileByUrl(profileUrl string) (*services.ConfigProfile, error)
+	// SendGitIntegrationEvent sends a git integration event to xray
+	SendGitIntegrationEvent(event services.GitIntegrationEvent, xrayVersion string) error
 }

xsc/services/analytics.go

@@ -16,6 +16,7 @@ import (
 const (
 	AnalyticsMetricsMinXscVersion = "1.7.1"
 	xscEventApi                   = "event"
+	gitIntegrationEventApi        = "git_integration_event"
 	xscDeprecatedEventApiSuffix   = "api/v1/" + xscEventApi
 )
 
@@ -38,7 +39,11 @@ func (vs *AnalyticsEventService) getAnalyticsEndPoint() string {
 	return utils.AddTrailingSlashIfNeeded(vs.XscDetails.GetUrl()) + xscDeprecatedEventApiSuffix
 }
 
-func (vs *AnalyticsEventService) sendPostRequest(requestContent []byte) (resp *http.Response, body []byte, err error) {
+func (vs *AnalyticsEventService) getGitEventEndPoint() string {
+	return utils.AddTrailingSlashIfNeeded(vs.XrayDetails.GetUrl()) + xscutils.XscInXraySuffix + gitIntegrationEventApi
+}
+
+func (vs *AnalyticsEventService) sendAddGeneralEventPostRequest(requestContent []byte) (resp *http.Response, body []byte, err error) {
 	var httpClientDetails httputils.HttpClientDetails
 	if vs.XrayDetails != nil {
 		httpClientDetails = vs.XrayDetails.CreateHttpClientDetails()
@@ -50,6 +55,12 @@ func (vs *AnalyticsEventService) sendPostRequest(requestContent []byte) (resp *h
 	return
 }
 
+func (vs *AnalyticsEventService) sendGitIntegrationPostRequest(requestContent []byte) (resp *http.Response, body []byte, err error) {
+	var httpClientDetails = vs.XrayDetails.CreateHttpClientDetails()
+	resp, body, err = vs.client.SendPost(utils.AppendScopedProjectKeyParam(vs.getGitEventEndPoint(), vs.ScopeProjectKey), requestContent, &httpClientDetails)
+	return
+}
+
 func (vs *AnalyticsEventService) sendPutRequest(requestContent []byte) (resp *http.Response, body []byte, err error) {
 	var httpClientDetails httputils.HttpClientDetails
 	if vs.XrayDetails != nil {
@@ -88,7 +99,7 @@ func (vs *AnalyticsEventService) AddGeneralEvent(event XscAnalyticsGeneralEvent,
 			return "", errorutils.CheckError(err)
 		}
 	}
-	resp, body, err := vs.sendPostRequest(requestContent)
+	resp, body, err := vs.sendAddGeneralEventPostRequest(requestContent)
 	if err != nil {
 		return "", err
 	}
@@ -100,6 +111,25 @@ func (vs *AnalyticsEventService) AddGeneralEvent(event XscAnalyticsGeneralEvent,
 	return response.MultiScanId, errorutils.CheckError(err)
 }
 
+// SendGitIntegrationEvent sends a POST request to the /git_integration_event endpoint
+func (vs *AnalyticsEventService) SendGitIntegrationEvent(event GitIntegrationEvent, xrayVersion string) error {
+	if err := utils.ValidateMinimumVersion(utils.Xray, xrayVersion, xscutils.MinXrayVersionGitIntegrationEvent); err != nil {
+		return fmt.Errorf("git integration event version error %s: %w", xscutils.MinXrayVersionGitIntegrationEvent, err)
+	}
+	requestBody, err := json.Marshal(event)
+	if err != nil {
+		return errorutils.CheckError(err)
+	}
+	resp, body, err := vs.sendGitIntegrationPostRequest(requestBody)
+	if err != nil {
+		return errorutils.CheckError(err)
+	}
+	if err = errorutils.CheckResponseStatus(resp, http.StatusCreated); err != nil {
+		return errorutils.CheckError(errorutils.GenerateResponseError(resp.Status, utils.IndentJson(body)))
+	}
+	return nil
+}
+
 // UpdateGeneralEvent update finalized analytics metrics info of an existing event.
 func (vs *AnalyticsEventService) UpdateGeneralEvent(event XscAnalyticsGeneralEventFinalize) error {
 	requestContent, err := json.Marshal(event)
@@ -201,6 +231,16 @@ type PullRequestContext struct {
 	PullRequestTitle string `json:"pull_request_title,omitempty"`
 }
 
+type GitIntegrationEvent struct {
+	EventType     string `json:"event_type"`
+	GitProvider   string `json:"git_provider"`
+	GitOwner      string `json:"git_owner"`
+	GitRepository string `json:"git_repository"`
+	GitBranch     string `json:"git_branch"`
+	EventStatus   string `json:"event_status"`
+	FailureReason string `json:"failure_reason,omitempty"`
+}
+
 type XscAnalyticsGeneralEventFinalize struct {
 	XscAnalyticsBasicGeneralEvent
 	MultiScanId string `json:"multi_scan_id,omitempty"`

xsc/services/utils/utils.go

@@ -15,6 +15,7 @@ const (
 	XscInXraySuffix                   = apiV1Suffix + xscSuffix
 	MinXrayVersionXscTransitionToXray = "3.107.13"
 	MinXrayVersionNewGitInfoContext   = "3.117.0"
+	MinXrayVersionGitIntegrationEvent = "3.135.0"
 )
 
 // From Xray version 3.107.13, XSC is transitioning to Xray as inner service. This function will return compatible URL.