Bitbucket Server integration tests

.github/workflows/test.yml

@@ -73,6 +73,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.pull_request.head.sha }}
+
       - name: Setup Go
         uses: actions/setup-go@v3
         with:
@@ -177,3 +178,29 @@ jobs:
           JF_URL: ${{ secrets.PLATFORM_URL }}
           JF_ACCESS_TOKEN: ${{ secrets.PLATFORM_ADMIN_TOKEN }}
           FROGBOT_TESTS_GITLAB_TOKEN: ${{ secrets.FROGBOT_TESTS_GITLAB_TOKEN }}
+
+  bitbucket-server-integration:
+    name: Bitbucket Server Integration Tests
+    needs: Pretest
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: Unzip Preconfigured Bitbucket Home
+        run: unzip ${{ github.workspace }}/testdata/resources/bitbucket_server_home.zip -d ${PWD}
+
+      - name: Download Bitbucket Server and Run
+        run: |
+          bb_script_path="${{ github.workspace }}/testdata/resources/bitbucket_server_run.sh"
+          chmod +x $bb_script_path
+          sh $bb_script_path
+
+      - name: Run Tests
+        env:
+          JF_URL: ${{ secrets.PLATFORM_URL }}
+          JF_ACCESS_TOKEN: ${{ secrets.PLATFORM_ADMIN_TOKEN }}
+          FROGBOT_TESTS_BB_SERVER_TOKEN: ${{ secrets.FROGBOT_TESTS_BB_SERVER_TOKEN }}
+          JFROG_CLI_LOG_LEVEL: "DEBUG"
+        run: go test -v bitbucket_server_test.go commands.go integrationutils.go

azure_test.go

@@ -27,14 +27,18 @@ func buildAzureReposIntegrationTestDetails(t *testing.T) *IntegrationTestDetails
 	return testDetails
 }
 
-func TestAzureRepos_ScanPullRequestIntegration(t *testing.T) {
+func azureReposTestsInit(t *testing.T) (vcsclient.VcsClient, *IntegrationTestDetails) {
 	testDetails := buildAzureReposIntegrationTestDetails(t)
 	azureClient := buildAzureReposClient(t, testDetails.GitToken)
+	return azureClient, testDetails
+}
+
+func TestAzureRepos_ScanPullRequestIntegration(t *testing.T) {
+	azureClient, testDetails := azureReposTestsInit(t)
 	runScanPullRequestCmd(t, azureClient, testDetails)
 }
 
 func TestAzureRepos_ScanRepositoryIntegration(t *testing.T) {
-	testDetails := buildAzureReposIntegrationTestDetails(t)
-	azureClient := buildAzureReposClient(t, testDetails.GitToken)
+	azureClient, testDetails := azureReposTestsInit(t)
 	runScanRepositoryCmd(t, azureClient, testDetails)
 }

bitbucket_server_test.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"github.com/jfrog/frogbot/utils"
+	"github.com/jfrog/froggit-go/vcsclient"
+	"github.com/jfrog/froggit-go/vcsutils"
+	"github.com/jfrog/jfrog-client-go/utils/log"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"io"
+	"net/http"
+	"testing"
+)
+
+const (
+	bitbucketServerIntegrationTokenEnv = "FROGBOT_TESTS_BB_SERVER_TOKEN"
+	bitbucketServerApiEndpoint         = "http://localhost:7990/rest"
+	bitbucketServerGitCloneUrl         = "http://localhost:7990/scm/frog/integration.git"
+)
+
+func buildBitbucketServerClient(t *testing.T, bitbucketServerToken string) vcsclient.VcsClient {
+	bbClient, err := vcsclient.NewClientBuilder(vcsutils.BitbucketServer).Username("frogbot").ApiEndpoint(bitbucketServerApiEndpoint).Token(bitbucketServerToken).Build()
+	assert.NoError(t, err)
+	return bbClient
+}
+
+func buildBitbucketServerIntegrationTestDetails(t *testing.T) *IntegrationTestDetails {
+	integrationRepoToken := getIntegrationToken(t, bitbucketServerIntegrationTokenEnv)
+	testDetails := NewIntegrationTestDetails(integrationRepoToken, string(utils.BitbucketServer), bitbucketServerGitCloneUrl, "FROG")
+	testDetails.ApiEndpoint = bitbucketServerApiEndpoint
+	return testDetails
+}
+
+func waitForConnection(t *testing.T) {
+	log.Info("Waiting for Bitbucket Server to be up and running...")
+	retryExecutor := vcsutils.RetryExecutor{
+		MaxRetries:               10,
+		RetriesIntervalMilliSecs: 60000,
+		Logger:                   log.Logger,
+	}
+	retryExecutor.ExecutionHandler = func() (bool, error) {
+		res, err := http.Get("http://localhost:7990/status")
+		if err != nil || res.StatusCode != http.StatusOK {
+			body, e := io.ReadAll(res.Body)
+			err = errors.Join(err, e)
+			log.Info(fmt.Sprintf("Status code: %d, Server current state: %s", res.StatusCode, body))
+			return true, err
+		}
+		return false, nil
+	}
+	require.NoError(t, retryExecutor.Execute())
+}
+
+func bitbucketServerTestsInit(t *testing.T) (vcsclient.VcsClient, *IntegrationTestDetails) {
+	testDetails := buildBitbucketServerIntegrationTestDetails(t)
+	bbClient := buildBitbucketServerClient(t, testDetails.GitToken)
+	waitForConnection(t)
+	return bbClient, testDetails
+}
+
+func TestBitbucketServer_ScanPullRequestIntegration(t *testing.T) {
+	bbClient, testDetails := bitbucketServerTestsInit(t)
+	runScanPullRequestCmd(t, bbClient, testDetails)
+}
+
+func TestBitbucketServer_ScanRepositoryIntegration(t *testing.T) {
+	bbClient, testDetails := bitbucketServerTestsInit(t)
+	runScanRepositoryCmd(t, bbClient, testDetails)
+}

github_test.go

@@ -24,15 +24,18 @@ func buildGitHubIntegrationTestDetails(t *testing.T) *IntegrationTestDetails {
 	return NewIntegrationTestDetails(integrationRepoToken, string(utils.GitHub), githubGitCloneUrl, "frogbot-test")
 }
 
-func TestGitHub_ScanPullRequestIntegration(t *testing.T) {
+func githubTestsInit(t *testing.T) (vcsclient.VcsClient, *IntegrationTestDetails) {
 	testDetails := buildGitHubIntegrationTestDetails(t)
-	// Create a client for REST API request
 	githubClient := buildGitHubClient(t, testDetails.GitToken)
+	return githubClient, testDetails
+}
+
+func TestGitHub_ScanPullRequestIntegration(t *testing.T) {
+	githubClient, testDetails := githubTestsInit(t)
 	runScanPullRequestCmd(t, githubClient, testDetails)
 }
 
 func TestGitHub_ScanRepositoryIntegration(t *testing.T) {
-	testDetails := buildGitHubIntegrationTestDetails(t)
-	githubClient := buildGitHubClient(t, testDetails.GitToken)
+	githubClient, testDetails := githubTestsInit(t)
 	runScanRepositoryCmd(t, githubClient, testDetails)
 }

gitlab_test.go

@@ -24,14 +24,18 @@ func buildGitLabIntegrationTestDetails(t *testing.T) *IntegrationTestDetails {
 	return NewIntegrationTestDetails(integrationRepoToken, string(utils.GitLab), gitlabGitCloneUrl, "frogbot-test2")
 }
 
-func TestGitLab_ScanPullRequestIntegration(t *testing.T) {
+func gitlabTestsInit(t *testing.T) (vcsclient.VcsClient, *IntegrationTestDetails) {
 	testDetails := buildGitLabIntegrationTestDetails(t)
 	gitlabClient := buildGitLabClient(t, testDetails.GitToken)
+	return gitlabClient, testDetails
+}
+
+func TestGitLab_ScanPullRequestIntegration(t *testing.T) {
+	gitlabClient, testDetails := gitlabTestsInit(t)
 	runScanPullRequestCmd(t, gitlabClient, testDetails)
 }
 
 func TestGitLab_ScanRepositoryIntegration(t *testing.T) {
-	testDetails := buildGitLabIntegrationTestDetails(t)
-	gitlabClient := buildGitLabClient(t, testDetails.GitToken)
+	gitlabClient, testDetails := gitlabTestsInit(t)
 	runScanRepositoryCmd(t, gitlabClient, testDetails)
 }

integrationutils.go

@@ -32,6 +32,7 @@ type IntegrationTestDetails struct {
 	GitCloneURL      string
 	GitProvider      string
 	GitProject       string
+	GitUsername      string
 	ApiEndpoint      string
 	PullRequestID    string
 	CustomBranchName string
@@ -43,14 +44,15 @@ func NewIntegrationTestDetails(token, gitProvider, gitCloneUrl, repoOwner string
 		RepoOwner:   repoOwner,
 		RepoName:    repoName,
 		GitToken:    token,
+		GitUsername: "frogbot",
 		GitProvider: gitProvider,
 		GitCloneURL: gitCloneUrl,
 	}
 }
 
 func buildGitManager(t *testing.T, testDetails *IntegrationTestDetails) *utils.GitManager {
 	gitManager, err := utils.NewGitManager().
-		SetAuth("", testDetails.GitToken).
+		SetAuth(testDetails.GitUsername, testDetails.GitToken).
 		SetEmailAuthor("[email protected]").
 		SetRemoteGitUrl(testDetails.GitCloneURL)
 	assert.NoError(t, err)
@@ -79,6 +81,7 @@ func setIntegrationTestEnvs(t *testing.T, testDetails *IntegrationTestDetails) f
 		utils.BranchNameTemplateEnv: testDetails.CustomBranchName,
 		utils.GitApiEndpointEnv:     testDetails.ApiEndpoint,
 		utils.GitProjectEnv:         testDetails.GitProject,
+		utils.GitUsernameEnv:        testDetails.GitUsername,
 		utils.GitBaseBranchEnv:      mainBranch,
 	})
 	return func() {
@@ -191,16 +194,16 @@ func runScanRepositoryCmd(t *testing.T, client vcsclient.VcsClient, testDetails
 	pullRequests := getOpenPullRequests(t, client, testDetails)
 
 	expectedBranchName := "frogbot-pyjwt-45ebb5a61916a91ae7c1e3ff7ffb6112-" + timestamp
-	assert.NoError(t, gitManager.RemoveRemoteBranch(expectedBranchName))
 	prId := findRelevantPrID(pullRequests, expectedBranchName)
 	assert.NotZero(t, prId)
 	closePullRequest(t, client, testDetails, prId)
+	assert.NoError(t, gitManager.RemoveRemoteBranch(expectedBranchName))
 
 	expectedBranchName = "frogbot-pyyaml-985622f4dbf3a64873b6b8440288e005-" + timestamp
 	prId = findRelevantPrID(pullRequests, expectedBranchName)
-	assert.NoError(t, gitManager.RemoveRemoteBranch(expectedBranchName))
 	assert.NotZero(t, prId)
 	closePullRequest(t, client, testDetails, prId)
+	assert.NoError(t, gitManager.RemoveRemoteBranch(expectedBranchName))
 }
 
 func validateResults(t *testing.T, ctx context.Context, client vcsclient.VcsClient, testDetails *IntegrationTestDetails, prID int) {
@@ -212,6 +215,8 @@ func validateResults(t *testing.T, ctx context.Context, client vcsclient.VcsClie
 		validateGitHubComments(t, ctx, actualClient, testDetails, prID, comments)
 	case *vcsclient.AzureReposClient:
 		validateAzureComments(t, comments)
+	case *vcsclient.BitbucketServerClient:
+		validateBitbucketServerComments(t, comments)
 	case *vcsclient.GitLabClient:
 		validateGitLabComments(t, comments)
 	}
@@ -220,7 +225,7 @@ func validateResults(t *testing.T, ctx context.Context, client vcsclient.VcsClie
 func validateGitHubComments(t *testing.T, ctx context.Context, client *vcsclient.GitHubClient, testDetails *IntegrationTestDetails, prID int, comments []vcsclient.CommentInfo) {
 	assert.Len(t, comments, 1)
 	comment := comments[0]
-	assert.Contains(t, comment.Content, outputwriter.VulnerabilitiesPrBannerSource)
+	assert.Contains(t, comment.Content, string(outputwriter.VulnerabilitiesPrBannerSource))
 
 	reviewComments, err := client.ListPullRequestReviewComments(ctx, testDetails.RepoOwner, testDetails.RepoName, prID)
 	assert.NoError(t, err)
@@ -229,12 +234,17 @@ func validateGitHubComments(t *testing.T, ctx context.Context, client *vcsclient
 
 func validateAzureComments(t *testing.T, comments []vcsclient.CommentInfo) {
 	assert.GreaterOrEqual(t, len(comments), expectedNumberOfIssues)
-	assertBannerExists(t, comments, outputwriter.VulnerabilitiesPrBannerSource)
+	assertBannerExists(t, comments, string(outputwriter.VulnerabilitiesPrBannerSource))
+}
+
+func validateBitbucketServerComments(t *testing.T, comments []vcsclient.CommentInfo) {
+	assert.GreaterOrEqual(t, len(comments), expectedNumberOfIssues)
+	assertBannerExists(t, comments, outputwriter.GetSimplifiedTitle(outputwriter.VulnerabilitiesPrBannerSource))
 }
 
 func validateGitLabComments(t *testing.T, comments []vcsclient.CommentInfo) {
 	assert.GreaterOrEqual(t, len(comments), expectedNumberOfIssues)
-	assertBannerExists(t, comments, outputwriter.VulnerabilitiesMrBannerSource)
+	assertBannerExists(t, comments, string(outputwriter.VulnerabilitiesMrBannerSource))
 }
 
 func getJfrogEnvRestoreFunc(t *testing.T) func() {
@@ -265,11 +275,11 @@ func getIntegrationToken(t *testing.T, tokenEnv string) string {
 	return integrationRepoToken
 }
 
-func assertBannerExists(t *testing.T, comments []vcsclient.CommentInfo, banner outputwriter.ImageSource) {
+func assertBannerExists(t *testing.T, comments []vcsclient.CommentInfo, banner string) {
 	var isContains bool
 	var occurrences int
 	for _, c := range comments {
-		if strings.Contains(c.Content, string(banner)) {
+		if strings.Contains(c.Content, banner) {
 			isContains = true
 			occurrences++
 		}
@@ -285,6 +295,6 @@ func closePullRequest(t *testing.T, client vcsclient.VcsClient, testDetails *Int
 		// The Azure API requires not adding parameters that won't be updated, so we omit the targetBranch in that case
 		targetBranch = ""
 	}
-	err := client.UpdatePullRequest(context.Background(), testDetails.RepoOwner, testDetails.RepoName, "scan pr test finished", "", targetBranch, prID, vcsutils.Closed)
+	err := client.UpdatePullRequest(context.Background(), testDetails.RepoOwner, testDetails.RepoName, "integration test finished", "", targetBranch, prID, vcsutils.Closed)
 	assert.NoError(t, err)
 }

testdata/resources/bitbucket_server_run.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+export BITBUCKET_VERSION=8.16.1
+export BITBUCKET_HOME=${PWD}/bitbucketHome
+
+# Download Bitbucket Server
+curl -fLg https://www.atlassian.com/software/stash/downloads/binary/atlassian-bitbucket-$BITBUCKET_VERSION.tar.gz -O
+
+# Extract Bitbucket Server
+tar -xvzf atlassian-bitbucket-$BITBUCKET_VERSION.tar.gz
+
+# Change directory to Bitbucket Server installation
+cd atlassian-bitbucket-$BITBUCKET_VERSION
+
+# Set Bitbucket home directory
+./bin/set-bitbucket-home.sh
+
+# Start Bitbucket Server
+./bin/start-bitbucket.sh --no-search

utils/git.go

@@ -161,7 +161,7 @@ func (gm *GitManager) Clone(destinationPath, branchName string) error {
 	transport.UnsupportedCapabilities = []capability.Capability{
 		capability.ThinPack,
 	}
-	log.Debug(fmt.Sprintf("Cloning <%s/%s/%s>...", gm.remoteGitUrl, gm.remoteName, GetFullBranchName(branchName)))
+	log.Debug(fmt.Sprintf("Running git clone %s (%s branch)...", gm.remoteGitUrl, branchName))
 	cloneOptions := &git.CloneOptions{
 		URL:           gm.remoteGitUrl,
 		Auth:          gm.auth,