diff --git a/artifactory_test.go b/artifactory_test.go index 9d5bd245b..9de331c31 100644 --- a/artifactory_test.go +++ b/artifactory_test.go @@ -7181,3 +7181,144 @@ func TestUploadMultipleFilesWithCIVcsProps(t *testing.T) { cleanArtifactoryTest() } + +// TestUploadWithLocalGitVcsProps verifies civcs local git fallback on rt upload +// when CI VCS env vars are absent but VCS collection is enabled. +func TestUploadWithLocalGitVcsProps(t *testing.T) { + initArtifactoryTest(t, "") + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + testDir := tests.CopyVcsGitFixture(t, tests.Temp) + targetPath := tests.RtRepo1 + "/local-git-vcs/" + + runRt(t, "upload", filepath.Join(testDir, "*.in"), targetPath, "--flat=true") + + resultItems := searchItemsInArtifactory(t, tests.SearchRepo1ByInSuffix) + assert.NotZero(t, len(resultItems)) + + var uploaded []rtutils.ResultItem + for _, item := range resultItems { + if item.Name == "a1.in" || item.Name == "a2.in" { + uploaded = append(uploaded, item) + } + } + assert.Len(t, uploaded, 2) + + tests.ValidateLocalGitVcsPropsOnArtifacts(t, uploaded, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + + cleanArtifactoryTest() +} + +// TestUploadWithLocalGitVcsPropsNestedRepo verifies upload from a subdirectory +// resolves the nearest .git (OtherGit), not the parent repo. +func TestUploadWithLocalGitVcsPropsNestedRepo(t *testing.T) { + initArtifactoryTest(t, "") + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + testDir := tests.CopyVcsGitFixture(t, tests.Temp) + targetPath := tests.RtRepo1 + "/local-git-vcs-nested/" + + runRt(t, "upload", filepath.Join(testDir, "OtherGit", "*.in"), targetPath, "--flat=true") + + resultItems := searchItemsInArtifactory(t, tests.SearchRepo1ByInSuffix) + var uploaded []rtutils.ResultItem + for _, item := range resultItems { + if item.Name == "b1.in" || item.Name == "b2.in" { + uploaded = append(uploaded, item) + } + } + assert.Len(t, uploaded, 2) + + tests.ValidateLocalGitVcsPropsOnArtifacts(t, uploaded, + tests.VcsFixtureOtherURL, tests.VcsFixtureOtherRevision, tests.VcsFixtureOtherBranch) + + cleanArtifactoryTest() +} + +func TestUploadUserPropsOverrideLocalGitVcs(t *testing.T) { + initArtifactoryTest(t, "") + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + testDir := tests.CopyVcsGitFixture(t, tests.Temp) + targetPath := tests.RtRepo1 + "/local-git-vcs-user-override/" + userProps := "vcs.url=https://example.com/custom.git;vcs.revision=deadbeef;vcs.branch=feature-x" + + runRt(t, "upload", filepath.Join(testDir, "a1.in"), targetPath, "--flat=true", "--target-props="+userProps) + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + props, err := serviceManager.GetItemProps(targetPath + "a1.in") + require.NoError(t, err) + require.Contains(t, props.Properties["vcs.url"], "https://example.com/custom.git") + require.Contains(t, props.Properties["vcs.revision"], "deadbeef") + require.Contains(t, props.Properties["vcs.branch"], "feature-x") + require.NotContains(t, props.Properties["vcs.url"], tests.VcsFixtureMainURL) + require.NotContains(t, props.Properties["vcs.revision"], tests.VcsFixtureMainRevision) + + cleanArtifactoryTest() +} + +// TestUploadCIPlusLocalGitVcsProps verifies CI provides provider/org/repo +// while local git fills url/revision/branch when CI env lacks them. +func TestUploadCIPlusLocalGitVcsProps(t *testing.T) { + initArtifactoryTest(t, "") + + cleanupEnv, actualOrg, actualRepo := tests.SetupGitHubActionsEnvForLocalGitMerge(t) + defer cleanupEnv() + + testDir := tests.CopyVcsGitFixture(t, tests.Temp) + targetPath := tests.RtRepo1 + "/local-git-vcs-ci-merge/" + + runRt(t, "upload", filepath.Join(testDir, "a1.in"), targetPath, "--flat=true") + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + props, err := serviceManager.GetItemProps(targetPath + "a1.in") + require.NoError(t, err) + + require.Contains(t, props.Properties["vcs.provider"], "github") + require.Contains(t, props.Properties["vcs.org"], actualOrg) + require.Contains(t, props.Properties["vcs.repo"], actualRepo) + require.Contains(t, props.Properties["vcs.url"], tests.VcsFixtureMainURL) + require.Contains(t, props.Properties["vcs.revision"], tests.VcsFixtureMainRevision) + require.Contains(t, props.Properties["vcs.branch"], tests.VcsFixtureMainBranch) + + cleanArtifactoryTest() +} + +func TestUploadNoLocalGitVcsWhenNoGitRepo(t *testing.T) { + initArtifactoryTest(t, "") + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + tmpDir, cleanupTmp := coretests.CreateTempDirWithCallbackAndAssert(t) + defer cleanupTmp() + + filePath := filepath.Join(tmpDir, "no-git.txt") + require.NoError(t, os.WriteFile(filePath, []byte("no git here"), 0644)) + + targetPath := tests.RtRepo1 + "/local-git-vcs-none/" + runRt(t, "upload", filePath, targetPath, "--flat=true") + + resultItems := searchItemsInArtifactory(t, tests.SearchAllRepo1) + var uploaded []rtutils.ResultItem + for _, item := range resultItems { + if item.Name == "no-git.txt" { + uploaded = append(uploaded, item) + } + } + require.Len(t, uploaded, 1) + tests.ValidateNoLocalGitVcsPropsOnArtifacts(t, uploaded) + + cleanArtifactoryTest() +} diff --git a/buildinfo_test.go b/buildinfo_test.go index 6c95699c2..5fb686c25 100644 --- a/buildinfo_test.go +++ b/buildinfo_test.go @@ -1234,6 +1234,42 @@ func TestBuildPublishWithCIVcsProps(t *testing.T) { cleanArtifactoryTest() } +// TestBuildPublishWithLocalGitVcsProps verifies build-publish sets local git VCS props +// when CI env is absent but VCS collection is enabled. +func TestBuildPublishWithLocalGitVcsProps(t *testing.T) { + initArtifactoryTest(t, "") + buildName := tests.RtBuildName1 + "-local-git" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + testDir := tests.CopyVcsGitFixture(t, tests.Temp) + runRt(t, "upload", filepath.Join(testDir, "a1.in"), tests.RtRepo1+"/local-git-bp/", "--flat=true", + "--build-name="+buildName, "--build-number="+buildNumber) + + runRt(t, "build-publish", buildName, buildNumber, "--dot-git-path", testDir) + + resultItems := getResultItemsFromArtifactory(tests.SearchAllRepo1, t) + require.Greater(t, len(resultItems), 0) + + var uploaded []rtutils.ResultItem + for _, item := range resultItems { + if item.Name == "a1.in" { + uploaded = append(uploaded, item) + } + } + require.NotEmpty(t, uploaded) + + tests.ValidateLocalGitVcsPropsOnArtifacts(t, uploaded, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + + cleanArtifactoryTest() +} + // TestBuildPublishWithoutCI tests that CI VCS properties are NOT set on artifacts // when running build-publish outside of a CI environment. func TestBuildPublishWithoutCI(t *testing.T) { diff --git a/go.mod b/go.mod index 1847d35d5..c4cb73c7a 100644 --- a/go.mod +++ b/go.mod @@ -21,7 +21,7 @@ require ( github.com/jfrog/build-info-go v1.13.1-0.20260615080618-42488b58c305 github.com/jfrog/gofrog v1.7.6 github.com/jfrog/jfrog-cli-application v1.0.2-0.20260621072921-cadb78770a3e - github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260623062654-89dd771ef4de + github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260701085637-6ba50cd3676f github.com/jfrog/jfrog-cli-core/v2 v2.60.1-0.20260624085155-5ba797de2616 github.com/jfrog/jfrog-cli-evidence v0.9.5-0.20260618135203-4d2bdd4ee35f github.com/jfrog/jfrog-cli-platform-services v1.10.1-0.20260618062042-6053ab368cab @@ -242,6 +242,8 @@ require ( sigs.k8s.io/yaml v1.6.0 // indirect ) +// replace github.com/jfrog/jfrog-cli-artifactory => github.com/jfrog/jfrog-cli-artifactory main + //replace github.com/gfleury/go-bitbucket-v1 => github.com/gfleury/go-bitbucket-v1 v0.0.0-20230825095122-9bc1711434ab //replace github.com/ktrysmt/go-bitbucket => github.com/ktrysmt/go-bitbucket v0.9.80 diff --git a/go.sum b/go.sum index 7cc72b13c..9973f63bc 100644 --- a/go.sum +++ b/go.sum @@ -67,6 +67,8 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= +github.com/attiasas/jfrog-cli-artifactory v0.0.0-20260625091513-237fc801b2b0 h1:oasuX75BZGWErXrMQk53gdekkGsn4xbcUjVpesd8R7M= +github.com/attiasas/jfrog-cli-artifactory v0.0.0-20260625091513-237fc801b2b0/go.mod h1:VqV0Bed11HoBlugAEGa3RumbwnDVslEf0gKocTzLs9s= github.com/aws/aws-sdk-go-v2 v1.41.7 h1:DWpAJt66FmnnaRIOT/8ASTucrvuDPZASqhhLey6tLY8= github.com/aws/aws-sdk-go-v2 v1.41.7/go.mod h1:4LAfZOPHNVNQEckOACQx60Y8pSRjIkNZQz1w92xpMJc= github.com/aws/aws-sdk-go-v2/config v1.32.17 h1:FpL4/758/diKwqbytU0prpuiu60fgXKUWCpDJtApclU= @@ -406,8 +408,8 @@ github.com/jfrog/jfrog-apps-config v1.0.1 h1:mtv6k7g8A8BVhlHGlSveapqf4mJfonwvXYL github.com/jfrog/jfrog-apps-config v1.0.1/go.mod h1:8AIIr1oY9JuH5dylz2S6f8Ym2MaadPLR6noCBO4C22w= github.com/jfrog/jfrog-cli-application v1.0.2-0.20260621072921-cadb78770a3e h1:jUfQzLCVbUazw7FEXf3+57vQheDSHa/Px/Gp4pf/sNI= github.com/jfrog/jfrog-cli-application v1.0.2-0.20260621072921-cadb78770a3e/go.mod h1:p8yLtbmCxxQucIbLZKnWu0F+EDtj6NLXbRQCEK/nb6o= -github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260623062654-89dd771ef4de h1:q2w1NMXsFQpcTCC++f0aLbzIvGovHXBpRpeBQWRpGLE= -github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260623062654-89dd771ef4de/go.mod h1:VqV0Bed11HoBlugAEGa3RumbwnDVslEf0gKocTzLs9s= +github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260701085637-6ba50cd3676f h1:PMq0iTjH/H40BEL/RzBwXFt7JMb+CQBaVmScdbZaeRI= +github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260701085637-6ba50cd3676f/go.mod h1:VqV0Bed11HoBlugAEGa3RumbwnDVslEf0gKocTzLs9s= github.com/jfrog/jfrog-cli-core/v2 v2.60.1-0.20260624085155-5ba797de2616 h1:bioFXGzf3pF2qnC3LZD1S1saWiHSekL4vdsDSWksj/4= github.com/jfrog/jfrog-cli-core/v2 v2.60.1-0.20260624085155-5ba797de2616/go.mod h1:9R90mhbczGXwW5EGlDs7F08ejQU/xdoDhYHMvzBiqgE= github.com/jfrog/jfrog-cli-evidence v0.9.5-0.20260618135203-4d2bdd4ee35f h1:MV4BATdkEoUYJmdPDvaB9EBb8JQZg28n/K4X7dcmyAY= diff --git a/utils/tests/artifact_props.go b/utils/tests/artifact_props.go new file mode 100644 index 000000000..172e2aadf --- /dev/null +++ b/utils/tests/artifact_props.go @@ -0,0 +1,88 @@ +package tests + +import ( + "strings" + "testing" + + buildinfo "github.com/jfrog/build-info-go/entities" + "github.com/jfrog/jfrog-client-go/artifactory" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// ArtifactFullPath builds the Artifactory item path for GetItemProps. +// When OriginalDeploymentRepo is empty (common with Gradle extractor build-info), +// defaultRepo is used as the repository prefix. +func ArtifactFullPath(a buildinfo.Artifact, defaultRepo string) string { + path := strings.TrimPrefix(a.Path, "/") + repo := a.OriginalDeploymentRepo + if repo == "" { + repo = defaultRepo + } + if repo != "" { + return repo + "/" + path + } + return path +} + +// ArtifactItemPath returns the Artifactory item path for GetItemProps. +// When Name is set and not already part of Path (e.g. UV stores Path as a directory), +// Name is appended as the filename segment. +func ArtifactItemPath(a buildinfo.Artifact, defaultRepo string) string { + fullPath := ArtifactFullPath(a, defaultRepo) + if a.Name == "" { + return fullPath + } + if strings.HasSuffix(fullPath, "/"+a.Name) || strings.HasSuffix(fullPath, a.Name) { + return fullPath + } + return fullPath + "/" + a.Name +} + +// ValidateLocalGitVcsPropsOnBuildInfoArtifacts fetches props for each build-info artifact +// and asserts local-git VCS fields. Returns the number of artifacts validated. +func ValidateLocalGitVcsPropsOnBuildInfoArtifacts( + t *testing.T, + serviceManager artifactory.ArtifactoryServicesManager, + publishedBuildInfo *buildinfo.PublishedBuildInfo, + defaultRepo string, + expectedURL, expectedRevision, expectedBranch string, +) int { + t.Helper() + require.NotNil(t, publishedBuildInfo) + + count := 0 + for _, module := range publishedBuildInfo.BuildInfo.Modules { + for _, artifact := range module.Artifacts { + fullPath := ArtifactItemPath(artifact, defaultRepo) + if fullPath == "" { + continue + } + + props, err := serviceManager.GetItemProps(fullPath) + require.NoError(t, err, "GetItemProps failed for %s", fullPath) + if props == nil { + assert.Fail(t, "Properties are nil for artifact: %s", fullPath) + continue + } + + assert.Contains(t, props.Properties, "vcs.url", "Missing vcs.url on %s", artifact.Name) + assert.Contains(t, props.Properties["vcs.url"], expectedURL, "Wrong vcs.url on %s", artifact.Name) + + assert.Contains(t, props.Properties, "vcs.revision", "Missing vcs.revision on %s", artifact.Name) + assert.Contains(t, props.Properties["vcs.revision"], expectedRevision, "Wrong vcs.revision on %s", artifact.Name) + + if expectedBranch != "" { + assert.Contains(t, props.Properties, "vcs.branch", "Missing vcs.branch on %s", artifact.Name) + assert.Contains(t, props.Properties["vcs.branch"], expectedBranch, "Wrong vcs.branch on %s", artifact.Name) + } + + // Local-git-only: provider/org/repo must NOT appear when CI is cleared + _, hasProvider := props.Properties["vcs.provider"] + assert.False(t, hasProvider, "vcs.provider should not be set on %s in local-git-only mode", artifact.Name) + + count++ + } + } + return count +} diff --git a/utils/tests/artifact_props_test.go b/utils/tests/artifact_props_test.go new file mode 100644 index 000000000..aaf8bbe01 --- /dev/null +++ b/utils/tests/artifact_props_test.go @@ -0,0 +1,57 @@ +package tests + +import ( + "testing" + + buildinfo "github.com/jfrog/build-info-go/entities" + "github.com/stretchr/testify/assert" +) + +func TestArtifactFullPath(t *testing.T) { + t.Run("uses OriginalDeploymentRepo when set", func(t *testing.T) { + a := buildinfo.Artifact{OriginalDeploymentRepo: "cli-gradle-123", Path: "com/foo/1.0/foo.jar"} + assert.Equal(t, "cli-gradle-123/com/foo/1.0/foo.jar", ArtifactFullPath(a, "fallback-repo")) + }) + + t.Run("falls back to defaultRepo when OriginalDeploymentRepo empty", func(t *testing.T) { + a := buildinfo.Artifact{Path: "com/foo/1.0/foo.jar"} + assert.Equal(t, "cli-gradle-123/com/foo/1.0/foo.jar", ArtifactFullPath(a, "cli-gradle-123")) + }) + + t.Run("falls back to Path when repo empty and no default", func(t *testing.T) { + a := buildinfo.Artifact{Path: "com/foo/1.0/foo.jar"} + assert.Equal(t, "com/foo/1.0/foo.jar", ArtifactFullPath(a, "")) + }) + + t.Run("strips leading slash from Path", func(t *testing.T) { + a := buildinfo.Artifact{Path: "/minimal-example/1.0/minimal-example-1.0.jar"} + assert.Equal(t, "cli-gradle-123/minimal-example/1.0/minimal-example-1.0.jar", ArtifactFullPath(a, "cli-gradle-123")) + }) +} + +func TestValidateLocalGitVcsPropsOnBuildInfoArtifacts_UsesArtifactFullPath(t *testing.T) { + // Smoke-test ArtifactFullPath integration used by the helper (no Artifactory call). + a := buildinfo.Artifact{ + OriginalDeploymentRepo: "", + Path: "/com/foo/1.0/foo.jar", + } + assert.Equal(t, "my-repo/com/foo/1.0/foo.jar", ArtifactFullPath(a, "my-repo")) +} + +func TestArtifactItemPath_AppendsNameForDirectoryPath(t *testing.T) { + a := buildinfo.Artifact{ + OriginalDeploymentRepo: "uv-local", + Path: "my-pkg/0.1.0", + Name: "my_pkg-0.1.0-py3-none-any.whl", + } + assert.Equal(t, "uv-local/my-pkg/0.1.0/my_pkg-0.1.0-py3-none-any.whl", ArtifactItemPath(a, "")) +} + +func TestArtifactItemPath_DoesNotDoubleAppendName(t *testing.T) { + a := buildinfo.Artifact{ + OriginalDeploymentRepo: "mvn-local", + Path: "com/foo/1.0/foo.jar", + Name: "foo.jar", + } + assert.Equal(t, "mvn-local/com/foo/1.0/foo.jar", ArtifactItemPath(a, "")) +} diff --git a/utils/tests/utils.go b/utils/tests/utils.go index 688b8ec42..bb1920322 100644 --- a/utils/tests/utils.go +++ b/utils/tests/utils.go @@ -923,6 +923,31 @@ func SetupGitHubActionsEnv(t *testing.T) (cleanup func(), actualOrg, actualRepo return cleanup, actualOrg, actualRepo } +// SetupGitHubActionsEnvForLocalGitMerge enables CI VCS collection with provider/org/repo +// but clears url/revision/branch CI env vars so local git fallback is exercised. +func SetupGitHubActionsEnvForLocalGitMerge(t *testing.T) (cleanup func(), actualOrg, actualRepo string) { + t.Helper() + cleanupBase, actualOrg, actualRepo := SetupGitHubActionsEnv(t) + + var callbacks []func() + for _, key := range []string{ + "GITHUB_SERVER_URL", + "GITHUB_SHA", + "GITHUB_REF", + "GITHUB_REF_NAME", + "GITHUB_HEAD_REF", + } { + callbacks = append(callbacks, tests.SetEnvWithCallbackAndAssert(t, key, "")) + } + + return func() { + for _, cb := range callbacks { + cb() + } + cleanupBase() + }, actualOrg, actualRepo +} + // ValidateCIVcsPropsOnArtifacts validates that CI VCS properties are set on artifacts. func ValidateCIVcsPropsOnArtifacts(t *testing.T, resultItems []utils.ResultItem, expectedProvider, expectedOrg, expectedRepo string) { for _, item := range resultItems { @@ -1021,3 +1046,76 @@ func ValidateCIVcsPropsIfPresent(t *testing.T, resultItems []utils.ResultItem, e } } } + +// SetupLocalGitVcsEnv enables VCS property collection and clears CI detection +// so only local git fallback is exercised. +func SetupLocalGitVcsEnv(t *testing.T) (cleanup func()) { + t.Helper() + var callbacks []func() + + for _, key := range []string{ + "JFROG_CLI_CI_VCS_PROPS_DISABLED", // set to "" to enable + "CI", "GITHUB_ACTIONS", "GITHUB_WORKFLOW", "GITHUB_RUN_ID", + "GITHUB_REPOSITORY", "GITHUB_REPOSITORY_OWNER", + "GITHUB_SERVER_URL", "GITHUB_SHA", "GITHUB_REF", "GITHUB_REF_NAME", "GITHUB_HEAD_REF", + } { + callbacks = append(callbacks, tests.SetEnvWithCallbackAndAssert(t, key, "")) + } + + return func() { + for _, cb := range callbacks { + cb() + } + } +} + +// ValidateLocalGitVcsPropsOnArtifacts asserts vcs.url, vcs.revision, vcs.branch on every item. +func ValidateLocalGitVcsPropsOnArtifacts(t *testing.T, resultItems []utils.ResultItem, expectedURL, expectedRevision, expectedBranch string) { + t.Helper() + for _, item := range resultItems { + propertiesMap := ConvertPropertiesToMap(item.Properties) + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.url", expectedURL) + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.revision", expectedRevision) + if expectedBranch != "" { + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.branch", expectedBranch) + } + } +} + +func assertLocalGitProp(t *testing.T, itemName string, props map[string][]string, key, expected string) { + t.Helper() + vals, ok := props[key] + assert.True(t, ok, "Missing %s on %s", key, itemName) + assert.Contains(t, vals, expected, "Wrong %s on %s", key, itemName) +} + +// ValidateNoLocalGitVcsPropsOnArtifacts asserts url/revision/branch are absent. +func ValidateNoLocalGitVcsPropsOnArtifacts(t *testing.T, resultItems []utils.ResultItem) { + t.Helper() + for _, item := range resultItems { + propertiesMap := ConvertPropertiesToMap(item.Properties) + _, hasURL := propertiesMap["vcs.url"] + _, hasRev := propertiesMap["vcs.revision"] + _, hasBranch := propertiesMap["vcs.branch"] + assert.False(t, hasURL, "vcs.url should not be set on %s", item.Name) + assert.False(t, hasRev, "vcs.revision should not be set on %s", item.Name) + assert.False(t, hasBranch, "vcs.branch should not be set on %s", item.Name) + } +} + +// ValidateCIAndLocalGitVcsPropsOnArtifacts asserts CI props plus local git props coexist. +func ValidateCIAndLocalGitVcsPropsOnArtifacts(t *testing.T, resultItems []utils.ResultItem, + expectedProvider, expectedOrg, expectedRepo, expectedURL, expectedRevision, expectedBranch string) { + t.Helper() + for _, item := range resultItems { + propertiesMap := ConvertPropertiesToMap(item.Properties) + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.provider", expectedProvider) + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.org", expectedOrg) + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.repo", expectedRepo) + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.url", expectedURL) + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.revision", expectedRevision) + if expectedBranch != "" { + assertLocalGitProp(t, item.Name, propertiesMap, "vcs.branch", expectedBranch) + } + } +} diff --git a/utils/tests/utils_test.go b/utils/tests/utils_test.go new file mode 100644 index 000000000..d384b9e8c --- /dev/null +++ b/utils/tests/utils_test.go @@ -0,0 +1,31 @@ +package tests + +import ( + "testing" + + "github.com/jfrog/build-info-go/utils/cienv" + "github.com/stretchr/testify/assert" +) + +func TestSetupGitHubActionsEnvForLocalGitMerge_ClearsUrlRevisionBranch(t *testing.T) { + t.Setenv("CI", "true") + t.Setenv("GITHUB_ACTIONS", "true") + t.Setenv("GITHUB_WORKFLOW", "wf") + t.Setenv("GITHUB_RUN_ID", "99") + t.Setenv("GITHUB_REPOSITORY_OWNER", "jfrog") + t.Setenv("GITHUB_REPOSITORY", "jfrog/jfrog-cli") + t.Setenv("GITHUB_SERVER_URL", "https://github.com") + t.Setenv("GITHUB_SHA", "abc123") + t.Setenv("GITHUB_REF", "refs/heads/feature") + + cleanup, _, _ := SetupGitHubActionsEnvForLocalGitMerge(t) + defer cleanup() + + info := cienv.GetCIVcsInfo() + assert.Equal(t, "github", info.Provider) + assert.Equal(t, "jfrog", info.Org) + assert.Equal(t, "jfrog-cli", info.Repo) + assert.Empty(t, info.Url) + assert.Empty(t, info.Revision) + assert.Empty(t, info.Branch) +} diff --git a/utils/tests/vcs_fixtures.go b/utils/tests/vcs_fixtures.go new file mode 100644 index 000000000..2b94d5cbf --- /dev/null +++ b/utils/tests/vcs_fixtures.go @@ -0,0 +1,92 @@ +package tests + +import ( + "os" + "path/filepath" + "runtime" + "testing" + + biutils "github.com/jfrog/build-info-go/utils" + coretests "github.com/jfrog/jfrog-cli-core/v2/utils/tests" + "github.com/jfrog/jfrog-client-go/utils/io/fileutils" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const ( + VcsFixtureMainURL = "https://github.com/jfrog/jfrog-cli.git" + VcsFixtureMainRevision = "d63c5957ad6819f4c02a817abe757f210d35ff92" + VcsFixtureMainBranch = "master" + + VcsFixtureOtherURL = "https://github.com/jfrog/jfrog-client-go.git" + VcsFixtureOtherRevision = "ad99b6c068283878fde4d49423728f0bdc00544a" + VcsFixtureOtherBranch = "InnerGit" +) + +// testResourcesDir returns the absolute path to the repo's testdata/ directory. +// It is resolved from this source file's location, not os.Getwd(). +func testResourcesDir() string { + _, filename, _, ok := runtime.Caller(0) + if !ok { + abs, err := filepath.Abs(filepath.FromSlash(GetTestResourcesPath())) + if err != nil { + return filepath.FromSlash(GetTestResourcesPath()) + } + return abs + } + abs, err := filepath.Abs(filepath.Join(filepath.Dir(filename), "..", "..", "testdata")) + if err != nil { + return filepath.Join(filepath.Dir(filename), "..", "..", "testdata") + } + return abs +} + +func vcsFixtureSrcDir() string { + return filepath.Join(testResourcesDir(), "vcs") +} + +func vcsGitdataSrcDir() string { + return filepath.Join(vcsFixtureSrcDir(), "gitdata") +} + +// CopyVcsGitFixture copies testdata/vcs into destDir and renames gitdata -> .git. +// Returns the absolute path to destDir. +func CopyVcsGitFixture(t *testing.T, destDir string) string { + t.Helper() + src := vcsFixtureSrcDir() + assert.NoError(t, biutils.CopyDir(src, destDir, true, nil)) + if found, err := fileutils.IsDirExists(filepath.Join(destDir, "gitdata"), false); found { + assert.NoError(t, err) + coretests.RenamePath(filepath.Join(destDir, "gitdata"), filepath.Join(destDir, ".git"), t) + } + if found, err := fileutils.IsDirExists(filepath.Join(destDir, "OtherGit", "gitdata"), false); found { + assert.NoError(t, err) + coretests.RenamePath( + filepath.Join(destDir, "OtherGit", "gitdata"), + filepath.Join(destDir, "OtherGit", ".git"), + t, + ) + } + abs, err := filepath.Abs(destDir) + assert.NoError(t, err) + return abs +} + +// CopyGitFixtureIntoProject installs testdata/vcs/gitdata as projectDir/.git. +func CopyGitFixtureIntoProject(t *testing.T, projectDir string) { + t.Helper() + src := vcsGitdataSrcDir() + gitDir := filepath.Join(projectDir, ".git") + stagingDir := filepath.Join(projectDir, "gitdata-staging") + + if fileutils.IsPathExists(gitDir, false) { + require.NoError(t, os.RemoveAll(gitDir)) + } + require.NoError(t, os.RemoveAll(stagingDir)) + + require.NoError(t, biutils.CopyDir(src, stagingDir, true, nil)) + coretests.RenamePath(stagingDir, gitDir, t) + + require.FileExists(t, filepath.Join(gitDir, "HEAD")) + require.FileExists(t, filepath.Join(gitDir, "config")) +} diff --git a/utils/tests/vcs_fixtures_test.go b/utils/tests/vcs_fixtures_test.go new file mode 100644 index 000000000..a9968101a --- /dev/null +++ b/utils/tests/vcs_fixtures_test.go @@ -0,0 +1,27 @@ +package tests + +import ( + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestCopyGitFixtureIntoProject_WorksAfterChdir(t *testing.T) { + repoRoot, err := os.Getwd() + require.NoError(t, err) + + projectDir := t.TempDir() + subDir := filepath.Join(projectDir, "nested") + require.NoError(t, os.MkdirAll(subDir, 0o755)) + + // Simulate prepareGoProject leaving cwd inside the project tree. + require.NoError(t, os.Chdir(subDir)) + t.Cleanup(func() { _ = os.Chdir(repoRoot) }) + + CopyGitFixtureIntoProject(t, projectDir) + + require.FileExists(t, filepath.Join(projectDir, ".git", "HEAD")) + require.FileExists(t, filepath.Join(projectDir, ".git", "config")) +}