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/conan_test.go b/conan_test.go index a7334b185..032e5e00e 100644 --- a/conan_test.go +++ b/conan_test.go @@ -7,6 +7,7 @@ import ( "os/exec" "path/filepath" "strconv" + "strings" "testing" buildinfo "github.com/jfrog/build-info-go/entities" @@ -1162,3 +1163,54 @@ func TestConanBuildPublishWithCIVcsProps(t *testing.T) { assert.Greater(t, artifactCount, 0, "No artifacts were validated for CI VCS properties") } + +// TestConanUploadWithLocalGitVcsProps verifies civcs local git fallback on conan upload. +func TestConanUploadWithLocalGitVcsProps(t *testing.T) { + initConanTest(t) + + buildName := tests.ConanBuildName + "-local-git" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + projectPath := createConanProject(t, "conan-local-git") + tests.CopyGitFixtureIntoProject(t, projectPath) + + conanfile := filepath.Join(projectPath, "conanfile.py") + data, err := os.ReadFile(conanfile) + require.NoError(t, err) + patched := strings.ReplaceAll(string(data), `name = "cli-test-package"`, `name = "cli-test-package-local-git"`) + require.NoError(t, os.WriteFile(conanfile, []byte(patched), 0o644)) //#nosec G703 -- test code, path built from createConanProject temp dir + + wd, err := os.Getwd() + require.NoError(t, err) + chdirCallback := clientTestUtils.ChangeDirWithCallback(t, wd, projectPath) + defer chdirCallback() + + configureConanRemote(t) + defer cleanupConanRemote() + + jfrogCli := coretests.NewJfrogCli(execMain, "jfrog", "") + require.NoError(t, jfrogCli.Exec("conan", "create", ".", "--build=missing", + "--build-name="+buildName, "--build-number="+buildNumber)) + require.NoError(t, jfrogCli.Exec("conan", "upload", "cli-test-package-local-git/*", + "-r", tests.ConanLocalRepo, "--confirm", + "--build-name="+buildName, "--build-number="+buildNumber)) + + require.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + require.NoError(t, err) + require.True(t, found) + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.ConanLocalRepo, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) +} diff --git a/go.mod b/go.mod index caaae61f9..44980cfa7 100644 --- a/go.mod +++ b/go.mod @@ -242,6 +242,9 @@ require ( sigs.k8s.io/yaml v1.6.0 // indirect ) +// attiasas:expend_vsc_detection +replace github.com/jfrog/jfrog-cli-artifactory => github.com/attiasas/jfrog-cli-artifactory v0.0.0-20260623073101-d9677917e68d + //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 11ab7287d..eb085c2ee 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-20260623073101-d9677917e68d h1:2GtEL0QARCe/D976gddr8GDr42WfXS9TInvkohoDd5s= +github.com/attiasas/jfrog-cli-artifactory v0.0.0-20260623073101-d9677917e68d/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,6 @@ 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.20260617073349-d68ee3120aa8 h1:FG+SfgPgrIuBHSos4sw4KNZq2MKxebbCZ6KZZRfaYcs= github.com/jfrog/jfrog-cli-application v1.0.2-0.20260617073349-d68ee3120aa8/go.mod h1:p8yLtbmCxxQucIbLZKnWu0F+EDtj6NLXbRQCEK/nb6o= -github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260623043151-6ed368aaea7f h1:NnFf3sTty9i5k22iMNEZWlHJp49/1AlWOCU1qc9VK4A= -github.com/jfrog/jfrog-cli-artifactory v0.8.1-0.20260623043151-6ed368aaea7f/go.mod h1:VqV0Bed11HoBlugAEGa3RumbwnDVslEf0gKocTzLs9s= github.com/jfrog/jfrog-cli-core/v2 v2.60.1-0.20260615072209-8ccac4f0072e h1:E3B8OyEkCsdEdGsZifTphBDUPrd00yKoemL9+l25Qj8= github.com/jfrog/jfrog-cli-core/v2 v2.60.1-0.20260615072209-8ccac4f0072e/go.mod h1:9R90mhbczGXwW5EGlDs7F08ejQU/xdoDhYHMvzBiqgE= github.com/jfrog/jfrog-cli-evidence v0.9.5-0.20260601141509-8df6c9a4bc9b h1:V0FxnU3xh29y8yJHWymm6rPr1MrjG1DdPQlr3ckImwk= diff --git a/go_test.go b/go_test.go index 1c9a2e304..79a7a7520 100644 --- a/go_test.go +++ b/go_test.go @@ -469,23 +469,20 @@ func TestGoBuildPublishWithCIVcsProps(t *testing.T) { assert.NoError(t, err) // Verify VCS properties on each artifact from build info - // Use same fallback logic as CI VCS: OriginalDeploymentRepo + Path, or Path directly artifactCount := 0 for _, module := range publishedBuildInfo.BuildInfo.Modules { for _, artifact := range module.Artifacts { - var fullPath string - switch { - case artifact.OriginalDeploymentRepo != "": - fullPath = artifact.OriginalDeploymentRepo + "/" + artifact.Path - case artifact.Path != "": - fullPath = artifact.Path - default: - continue // Skip artifacts without any path info + fullPath := tests.ArtifactFullPath(artifact, tests.GoRepo) + if fullPath == "" { + continue } props, err := serviceManager.GetItemProps(fullPath) assert.NoError(t, err, "Failed to get properties for artifact: %s", fullPath) assert.NotNil(t, props, "Properties are nil for artifact: %s", fullPath) + if props == nil { + continue + } // Validate VCS properties assert.Contains(t, props.Properties, "vcs.provider", "Missing vcs.provider on %s", artifact.Name) @@ -503,3 +500,57 @@ func TestGoBuildPublishWithCIVcsProps(t *testing.T) { assert.Greater(t, artifactCount, 0, "No artifacts were validated for CI VCS properties") } + +// TestGoPublishWithLocalGitVcsProps tests that local git VCS properties are set on Go artifacts +// when running go-publish followed by build-publish with VCS collection enabled and no CI env. +func TestGoPublishWithLocalGitVcsProps(t *testing.T) { + _, cleanUpFunc := initGoTest(t) + defer cleanUpFunc() + + buildName := tests.GoBuildName + "-local-git" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + wd, err := os.Getwd() + assert.NoError(t, err, "Failed to get current dir") + + projectPath := createGoProject(t, "project1", true) + testdataTarget := filepath.Join(tests.Out, "testdata") + testdataSrc := filepath.Join(filepath.FromSlash(tests.GetTestResourcesPath()), "go", "testdata") + require.NoError(t, biutils.CopyDir(testdataSrc, testdataTarget, true, nil)) + configFileDir := filepath.Join(filepath.FromSlash(tests.GetTestResourcesPath()), "go", "project1", ".jfrog", "projects") + _, err = tests.ReplaceTemplateVariables(filepath.Join(configFileDir, "go.yaml"), filepath.Join(projectPath, ".jfrog", "projects")) + require.NoError(t, err) + + tests.CopyGitFixtureIntoProject(t, projectPath) + require.FileExists(t, filepath.Join(projectPath, ".git", "HEAD")) + clientTestUtils.ChangeDirAndAssert(t, projectPath) + defer clientTestUtils.ChangeDirAndAssert(t, wd) + log.Info("Using Go project located at", projectPath) + + jfrogCli := coretests.NewJfrogCli(execMain, "jfrog", "") + err = execGo(jfrogCli, "go", "build", "--mod=mod", "--build-name="+buildName, "--build-number="+buildNumber) + assert.NoError(t, err) + + err = execGo(jfrogCli, "gp", "--build-name="+buildName, "--build-number="+buildNumber, "v1.0.0") + assert.NoError(t, err) + + err = execGo(artifactoryCli, "bp", buildName, buildNumber) + assert.NoError(t, err) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + assert.NoError(t, err) + assert.True(t, found, "Build info was not found") + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + assert.NoError(t, err) + + artifactCount := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, + tests.GoRepo, tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, artifactCount, 0) +} diff --git a/gradle_test.go b/gradle_test.go index 74c0a60a8..725c2641d 100644 --- a/gradle_test.go +++ b/gradle_test.go @@ -707,11 +707,14 @@ func TestGradleBuildPublishWithCIVcsProps(t *testing.T) { artifactCount := 0 for _, module := range publishedBuildInfo.BuildInfo.Modules { for _, artifact := range module.Artifacts { - fullPath := artifact.OriginalDeploymentRepo + "/" + artifact.Path + fullPath := tests.ArtifactFullPath(artifact, tests.GradleRepo) props, err := serviceManager.GetItemProps(fullPath) assert.NoError(t, err, "Failed to get properties for artifact: %s", fullPath) assert.NotNil(t, props, "Properties are nil for artifact: %s", fullPath) + if props == nil { + continue + } // Validate VCS properties assert.Contains(t, props.Properties, "vcs.provider", "Missing vcs.provider on %s", artifact.Name) @@ -730,3 +733,104 @@ func TestGradleBuildPublishWithCIVcsProps(t *testing.T) { cleanGradleTest(t) } + +// TestGradleBuildPublishWithLocalGitVcsProps tests that local git VCS properties are set on Gradle artifacts +// when running build-publish with VCS collection enabled and no CI env. +// Uses the traditional Gradle extractor path (not FlexPack) because SetCIVcsPropsToConfig +// injects local git props into the extractor config; FlexPack only sets build.* props on publish. +func TestGradleBuildPublishWithLocalGitVcsProps(t *testing.T) { + initGradleTest(t) + buildName := "gradle-local-git-test" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + _ = os.Unsetenv("JFROG_RUN_NATIVE") + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + buildGradlePath := createGradleProject(t, "gradleproject") + projectDir := filepath.Dir(buildGradlePath) + tests.CopyGitFixtureIntoProject(t, projectDir) + require.FileExists(t, filepath.Join(projectDir, ".git", "HEAD")) + + configFilePath := filepath.Join(filepath.FromSlash(tests.GetTestResourcesPath()), "buildspecs", tests.GradleConfig) + createConfigFile(filepath.Join(projectDir, ".jfrog", "projects"), configFilePath, t) + + oldHomeDir := changeWD(t, projectDir) + defer clientTestUtils.ChangeDirAndAssert(t, oldHomeDir) + + buildGradlePath = strings.ReplaceAll(buildGradlePath, `\`, "/") + runJfrogCli(t, "gradle", "clean", "artifactoryPublish", "-b"+buildGradlePath, "--build-name="+buildName, "--build-number="+buildNumber) + + assert.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + clientTestUtils.ChangeDirAndAssert(t, oldHomeDir) + + var publishedBuildInfo *buildinfo.PublishedBuildInfo + var found bool + assert.Eventuallyf(t, func() bool { + var biErr error + publishedBuildInfo, found, biErr = tests.GetBuildInfo(serverDetails, buildName, buildNumber) + return biErr == nil && found + }, 30*time.Second, 2*time.Second, "Build info was not found for %s/%s", buildName, buildNumber) + if !found || publishedBuildInfo == nil { + return + } + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + assert.NoError(t, err) + + artifactCount := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, + tests.GradleRepo, tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, artifactCount, 0) + + cleanGradleTest(t) +} + +// TestGradleFlexPackPublishWithLocalGitVcsProps verifies local git VCS on FlexPack publish path. +func TestGradleFlexPackPublishWithLocalGitVcsProps(t *testing.T) { + initGradleTest(t) + buildName := "gradle-flexpack-local-git" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + setEnvCallBack := clientTestUtils.SetEnvWithCallbackAndAssert(t, "JFROG_RUN_NATIVE", "true") + defer setEnvCallBack() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + buildGradlePath := createGradleProject(t, "civcsproject") + projectDir := filepath.Dir(buildGradlePath) + tests.CopyGitFixtureIntoProject(t, projectDir) + + oldHomeDir := changeWD(t, projectDir) + defer clientTestUtils.ChangeDirAndAssert(t, oldHomeDir) + + runJfrogCli(t, "gradle", "clean", "publish", "--build-name="+buildName, "--build-number="+buildNumber) + require.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + clientTestUtils.ChangeDirAndAssert(t, oldHomeDir) + + var publishedBuildInfo *buildinfo.PublishedBuildInfo + var found bool + require.Eventually(t, func() bool { + var biErr error + publishedBuildInfo, found, biErr = tests.GetBuildInfo(serverDetails, buildName, buildNumber) + return biErr == nil && found + }, 30*time.Second, 2*time.Second) + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.GradleRepo, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) + + cleanGradleTest(t) +} diff --git a/maven_test.go b/maven_test.go index 54a55ee51..cf98f710d 100644 --- a/maven_test.go +++ b/maven_test.go @@ -839,3 +839,50 @@ func TestMavenBuildPublishWithCIVcsProps(t *testing.T) { cleanMavenTest(t) } + +// TestMavenBuildPublishWithLocalGitVcsProps verifies local git VCS props on Maven artifacts +// when running build-publish with VCS collection enabled and no CI env. +func TestMavenBuildPublishWithLocalGitVcsProps(t *testing.T) { + initMavenTest(t, false) + buildName := tests.MvnBuildName + "-local-git" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + pomDir := createSimpleMavenProject(t) + tests.CopyGitFixtureIntoProject(t, pomDir) + require.FileExists(t, filepath.Join(pomDir, ".git", "HEAD")) + + configFilePath := filepath.Join(filepath.FromSlash(tests.GetTestResourcesPath()), "buildspecs", tests.MavenConfig) + destPath := filepath.Join(pomDir, ".jfrog", "projects") + createConfigFile(destPath, configFilePath, t) + require.NoError(t, os.Rename(filepath.Join(destPath, tests.MavenConfig), filepath.Join(destPath, "maven.yaml"))) + + oldHomeDir := changeWD(t, pomDir) + defer clientTestUtils.ChangeDirAndAssert(t, oldHomeDir) + + repoLocalSystemProp := localRepoSystemProperty + localRepoDir + args := []string{"mvn", "clean", "install", "-B", repoLocalSystemProp, + "--build-name=" + buildName, "--build-number=" + buildNumber} + require.NoError(t, runJfrogCliWithoutAssertion(args...)) + + // Must run build-publish from project dir so GetLocalGitVcsInfo finds the fixture .git + runRt(t, "build-publish", buildName, buildNumber) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + require.NoError(t, err) + require.True(t, found, "Build info was not found") + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.MvnRepo1, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) + + cleanMavenTest(t) +} diff --git a/nix_test.go b/nix_test.go index 9eac5a39d..4380ab43e 100644 --- a/nix_test.go +++ b/nix_test.go @@ -10,6 +10,7 @@ import ( buildinfo "github.com/jfrog/build-info-go/entities" biutils "github.com/jfrog/build-info-go/utils" + "github.com/jfrog/jfrog-cli-core/v2/artifactory/utils" "github.com/jfrog/jfrog-cli-core/v2/utils/coreutils" coretests "github.com/jfrog/jfrog-cli-core/v2/utils/tests" clientTestUtils "github.com/jfrog/jfrog-client-go/utils/tests" @@ -495,6 +496,60 @@ func TestNixCopy_VirtualToLocalResolution(t *testing.T) { inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) } +func TestNixCopyWithLocalGitVcsProps(t *testing.T) { + initNixTest(t) + + oldHomeDir, newHomeDir := prepareHomeDir(t) + defer func() { + clientTestUtils.SetEnvAndAssert(t, coreutils.HomeDir, oldHomeDir) + clientTestUtils.RemoveAllAndAssert(t, newHomeDir) + }() + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + buildName := "nix-copy-local-git" + buildNumber := "1" + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + projectDir, cleanupProject := createNixProject(t, "nix-local-git", "channelproject") + defer cleanupProject() + tests.CopyGitFixtureIntoProject(t, projectDir) + + wd, err := os.Getwd() + require.NoError(t, err) + chdirCallback := clientTestUtils.ChangeDirWithCallback(t, wd, projectDir) + defer chdirCallback() + + jfrogCli := coretests.NewJfrogCli(execMain, "jfrog", "") + err = jfrogCli.Exec("nix", "nix-build", "", "-A", "hello", + "--build-name="+buildName, "--build-number="+buildNumber) + if err != nil { + t.Skipf("nix-build not available: %v", err) + } + + toURL := fmt.Sprintf("https://%s:%s@%s/api/nix/%s/", + *tests.JfrogUser, *tests.JfrogPassword, + strings.TrimPrefix(strings.TrimPrefix(*tests.JfrogUrl, "https://"), "http://"), + tests.NixLocalRepo) + require.NoError(t, jfrogCli.Exec("nix", "copy", "--to", toURL, "./result", + "--build-name="+buildName, "--build-number="+buildNumber)) + + require.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + require.NoError(t, err) + require.True(t, found) + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.NixLocalRepo, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) +} + func TestNixBuild_BuildOnlyNoCopy(t *testing.T) { initNixTest(t) diff --git a/npm_test.go b/npm_test.go index c5e679664..38c0ddf37 100644 --- a/npm_test.go +++ b/npm_test.go @@ -309,7 +309,6 @@ func appendRegistryAuthToNpmrc(t *testing.T, registryURL string) error { return err } - func readModuleId(t *testing.T, wd string, npmVersion *version.Version) string { packageInfo, err := buildutils.ReadPackageInfoFromPackageJsonIfExists(filepath.Dir(wd), npmVersion) assert.NoError(t, err) @@ -483,7 +482,6 @@ func initNpmProjectTest(t *testing.T) (npmProjectPath string) { return } - func initNpmWorkspacesProjectTest(t *testing.T) (npmProjectPath string) { npmProjectPath = filepath.Dir(createNpmProject(t, "npmworkspaces")) err := createConfigFileForTest([]string{npmProjectPath}, tests.NpmRemoteRepo, tests.NpmRepo, t, project.Npm, false) @@ -1648,3 +1646,43 @@ func TestNpmBuildPublishWithCIVcsProps(t *testing.T) { } assert.Greater(t, artifactCount, 0, "No artifacts in build info") } + +// TestNpmPublishWithLocalGitVcsProps verifies local git VCS props on npm artifacts +// when running publish followed by build-publish with VCS collection enabled and no CI env. +func TestNpmPublishWithLocalGitVcsProps(t *testing.T) { + initNpmTest(t) + defer cleanNpmTest(t) + + buildName := "npm-local-git-test" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + wd, err := os.Getwd() + require.NoError(t, err) + + npmPath := initNpmProjectTest(t) + tests.CopyGitFixtureIntoProject(t, npmPath) + chdirCallBack := clientTestUtils.ChangeDirWithCallback(t, wd, npmPath) + defer chdirCallBack() + + runJfrogCli(t, "npm", "publish", "--build-name="+buildName, "--build-number="+buildNumber) + require.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + clientTestUtils.ChangeDirAndAssert(t, wd) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + require.NoError(t, err) + require.True(t, found) + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.NpmRepo, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) +} diff --git a/pip_test.go b/pip_test.go index 4ee8ac9d6..1f1e2dacb 100644 --- a/pip_test.go +++ b/pip_test.go @@ -777,3 +777,75 @@ func TestTwineBuildPublishWithCIVcsProps(t *testing.T) { assert.Greater(t, artifactCount, 0, "No artifacts were validated for CI VCS properties") } + +func TestTwinePublishWithLocalGitVcsProps(t *testing.T) { + initPipTest(t) + + buildName := tests.PipBuildName + "-local-git" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + oldHomeDir, newHomeDir := prepareHomeDir(t) + defer func() { + clientTestUtils.SetEnvAndAssert(t, coreutils.HomeDir, oldHomeDir) + clientTestUtils.RemoveAllAndAssert(t, newHomeDir) + }() + + cleanVirtualEnv, err := prepareVirtualEnv(t) + require.NoError(t, err) + defer cleanVirtualEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + projectPath := createPypiProject(t, "twine-local-git", "pyproject", "twine") + tests.CopyGitFixtureIntoProject(t, projectPath) + + pyproject := filepath.Join(projectPath, "pyproject.toml") + content, err := os.ReadFile(pyproject) + require.NoError(t, err) + patched := strings.ReplaceAll(string(content), `version = "1.0"`, `version = "1.0.1+localgit"`) + require.NoError(t, os.WriteFile(pyproject, []byte(patched), 0o644)) //#nosec G703 -- test code, path built from createPypiProject temp dir + + distDir := filepath.Join(projectPath, "dist") + require.NoError(t, os.RemoveAll(distDir)) + require.NoError(t, os.MkdirAll(distDir, 0o755)) + + installBuild := exec.Command("python", "-m", "pip", "install", "build") + installBuild.Dir = projectPath + installOut, err := installBuild.CombinedOutput() + require.NoError(t, err, "pip install build failed: %s", installOut) + + // --outdir is relative to buildCmd.Dir (projectPath), not the process CWD. + buildCmd := exec.Command("python", "-m", "build", "--outdir", "dist") + buildCmd.Dir = projectPath + buildOut, err := buildCmd.CombinedOutput() + require.NoError(t, err, "python build failed: %s", buildOut) + + entries, err := os.ReadDir(distDir) + require.NoError(t, err) + require.NotEmpty(t, entries, "dist must contain built artifacts after python -m build") + + wd, err := os.Getwd() + require.NoError(t, err) + chdirCallback := clientTestUtils.ChangeDirWithCallback(t, wd, projectPath) + defer chdirCallback() + + jfrogCli := coretests.NewJfrogCli(execMain, "jfrog", "") + require.NoError(t, jfrogCli.Exec("twine", "upload", "dist/*", + "--build-name="+buildName, "--build-number="+buildNumber)) + require.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + require.NoError(t, err) + require.True(t, found) + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.PypiVirtualRepo, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) +} diff --git a/pnpm_test.go b/pnpm_test.go index b471a894d..c0379f036 100644 --- a/pnpm_test.go +++ b/pnpm_test.go @@ -891,6 +891,52 @@ func TestPnpmBuildPublishWithCIVcsProps(t *testing.T) { assert.Greater(t, artifactCount, 0, "No artifacts in build info") } +// TestPnpmPublishWithLocalGitVcsProps verifies local git VCS props on pnpm artifacts +// when running publish followed by build-publish with VCS collection enabled and no CI env. +func TestPnpmPublishWithLocalGitVcsProps(t *testing.T) { + initPnpmTest(t) + defer cleanPnpmTest(t) + + buildName := "pnpm-local-git-test" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + wd, err := os.Getwd() + assert.NoError(t, err) + defer clientTestUtils.ChangeDirAndAssert(t, wd) + + pnpmProjectPath := createPnpmProject(t, "pnpmproject") + projectDir := filepath.Dir(pnpmProjectPath) + tests.CopyGitFixtureIntoProject(t, projectDir) + prepareArtifactoryForPnpmBuild(t, projectDir) + clientTestUtils.ChangeDirAndAssert(t, projectDir) + + cleanupAuth := setupPnpmPublishAuth(t, tests.NpmRepo) + defer cleanupAuth() + + runJfrogCli(t, "pnpm", "publish", "--no-git-checks", + "--build-name="+buildName, "--build-number="+buildNumber) + assert.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + clientTestUtils.ChangeDirAndAssert(t, wd) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + assert.NoError(t, err) + assert.True(t, found, "Build info was not found") + + serviceManager, err := utils.CreateServiceManager(serverDetails, 3, 1000, false) + assert.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.NpmRepo, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) +} + // TestPnpmInstallAndPublishWithProject verifies that pnpm install and publish work correctly // when targeting a non-default Artifactory project (RTECO-924). // The test uses --project flag with install, publish, and build-publish to verify that diff --git a/utils/tests/artifact_props.go b/utils/tests/artifact_props.go new file mode 100644 index 000000000..e763da591 --- /dev/null +++ b/utils/tests/artifact_props.go @@ -0,0 +1,106 @@ +package tests + +import ( + "path/filepath" + "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 +} + +// pathBasenameLooksLikeArchive reports whether the last segment of path is a +// deployable archive file (npm .tgz, Python .whl, Java .jar, etc.). +func pathBasenameLooksLikeArchive(path string) bool { + base := filepath.Base(strings.TrimSuffix(path, "/")) + for _, ext := range []string{".tgz", ".tar.gz", ".whl", ".jar", ".pom", ".zip", ".tar", ".tar.bz2"} { + if strings.HasSuffix(base, ext) { + return true + } + } + return false +} + +// 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 + } + // npm/pypi: Path is the full tarball path (e.g. pkg/-/pkg-1.0.0.tgz) + pathPart := strings.TrimPrefix(a.Path, "/") + if pathBasenameLooksLikeArchive(pathPart) { + 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..a88844006 --- /dev/null +++ b/utils/tests/artifact_props_test.go @@ -0,0 +1,66 @@ +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, "")) +} + +func TestArtifactItemPath_NpmTarballPathDoesNotAppendName(t *testing.T) { + a := buildinfo.Artifact{ + OriginalDeploymentRepo: "cli-npm-123", + Path: "jfrog-cli-tests/-/jfrog-cli-tests-1.0.0.tgz", + Name: "jfrog-cli-tests-v1.0.0.tgz", + } + assert.Equal(t, "cli-npm-123/jfrog-cli-tests/-/jfrog-cli-tests-1.0.0.tgz", 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")) +} diff --git a/uv_test.go b/uv_test.go index afe08fffa..97e85635c 100644 --- a/uv_test.go +++ b/uv_test.go @@ -11,8 +11,8 @@ import ( buildinfo "github.com/jfrog/build-info-go/entities" biutils "github.com/jfrog/build-info-go/utils" - coreBuild "github.com/jfrog/jfrog-cli-core/v2/common/build" artUtils "github.com/jfrog/jfrog-cli-core/v2/artifactory/utils" + coreBuild "github.com/jfrog/jfrog-cli-core/v2/common/build" coretests "github.com/jfrog/jfrog-cli-core/v2/utils/tests" clientTestUtils "github.com/jfrog/jfrog-client-go/utils/tests" "github.com/stretchr/testify/assert" @@ -50,11 +50,17 @@ func cleanUvTest(_ *testing.T) { tests.CleanFileSystem() } +const uvLocalGitVersion = "0.1.1+localgit" + // createUvProject copies a test UV project to a temp dir, injects Artifactory // URLs into pyproject.toml, then generates a fresh uv.lock against the test // Artifactory instance. The lock file is not committed to avoid embedding // instance-specific URLs in source. func createUvProject(t *testing.T, outputFolder, projectName string) string { + return createUvProjectWithVersion(t, outputFolder, projectName, "") +} + +func createUvProjectWithVersion(t *testing.T, outputFolder, projectName, version string) string { projectSrc := filepath.Join(filepath.FromSlash(tests.GetTestResourcesPath()), "uv", projectName) tmpDir, cleanup := coretests.CreateTempDirWithCallbackAndAssert(t) t.Cleanup(cleanup) @@ -72,6 +78,14 @@ func createUvProject(t *testing.T, outputFolder, projectName string) string { // Patch pyproject.toml with real Artifactory URLs for this test run patchUvPyprojectToml(t, projectPath) + if version != "" { + pyprojectPath := filepath.Join(projectPath, "pyproject.toml") + data, err := os.ReadFile(pyprojectPath) + require.NoError(t, err) + patched := strings.ReplaceAll(string(data), `version = "0.1.0"`, `version = "`+version+`"`) + require.NoError(t, os.WriteFile(filepath.Clean(pyprojectPath), []byte(patched), 0o644)) // #nosec G703 -- path built from filepath.Join, not user input + } + // Generate uv.lock against the patched index so UV resolves through // Artifactory (required for dependency checksum enrichment tests). // Convert the index name to the UV env var suffix format: @@ -422,9 +436,9 @@ func TestUvBuildFlags(t *testing.T) { expectErr bool // jfrog-cli errors if only one of name/number is set }{ {"both-set", tests.UvBuildName, "1", true, false}, - {"name-only", tests.UvBuildName, "", false, true}, // missing number → CLI error - {"number-only", "", "1", false, true}, // missing name → CLI error - {"neither", "", "", false, false}, // no flags → runs fine, no BI + {"name-only", tests.UvBuildName, "", false, true}, // missing number → CLI error + {"number-only", "", "1", false, true}, // missing name → CLI error + {"neither", "", "", false, false}, // no flags → runs fine, no BI } projectPath := createUvProject(t, "uv-flags", "uvproject") @@ -736,7 +750,8 @@ func TestUvNoPyprojectToml(t *testing.T) { // the dependencies declared in pyproject.toml — no more, no less. // // The test project (uvproject) declares one direct dependency: -// certifi>=2024.0.0 +// +// certifi>=2024.0.0 // // After `jf uv sync` the build info module must contain: // - Exactly 1 dependency (certifi; project itself is excluded) @@ -1490,6 +1505,39 @@ func TestUvBuildPublishWithCIVcsProps(t *testing.T) { assert.Greater(t, artifactCount, 0, "no artifacts were validated for CI VCS properties") } +func TestUvPublishWithLocalGitVcsProps(t *testing.T) { + initUvTest(t) + defer cleanUvTest(t) + + buildName := tests.UvBuildName + "-local-git" + buildNumber := "1" + + cleanupEnv := tests.SetupLocalGitVcsEnv(t) + defer cleanupEnv() + + inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + defer inttestutils.DeleteBuild(serverDetails.ArtifactoryUrl, buildName, artHttpDetails) + + projectPath := createUvProjectWithVersion(t, "uv-local-git", "uvproject", uvLocalGitVersion) + tests.CopyGitFixtureIntoProject(t, projectPath) + + require.NoError(t, runUvCmd(t, projectPath, "build")) + require.NoError(t, runUvCmd(t, projectPath, "publish", + "--build-name="+buildName, "--build-number="+buildNumber)) + require.NoError(t, artifactoryCli.Exec("bp", buildName, buildNumber)) + + publishedBuildInfo, found, err := tests.GetBuildInfo(serverDetails, buildName, buildNumber) + require.NoError(t, err) + require.True(t, found) + + serviceManager, err := artUtils.CreateServiceManager(serverDetails, 3, 1000, false) + require.NoError(t, err) + + count := tests.ValidateLocalGitVcsPropsOnBuildInfoArtifacts(t, serviceManager, publishedBuildInfo, tests.UvLocalRepo, + tests.VcsFixtureMainURL, tests.VcsFixtureMainRevision, tests.VcsFixtureMainBranch) + assert.Greater(t, count, 0) +} + // --------------------------------------------------------------------------- // P0 — Artifact sha256 not "untrusted" in Artifactory (#Cat7 NEW requirement) // ---------------------------------------------------------------------------