Fix misleading output when project has no .gitlab-ci.yml file (#395)

* Initial plan

* Fix misleading output when project has no .gitlab-ci.yml file

Co-authored-by: frjcomp <107982661+frjcomp@users.noreply.github.com>

* fix error detection, when no gitlab ci yml exists

* fmt

* Fix e2e test for updated FetchCICDYml behavior

Update TestGLCicdYaml_NoCiCdYaml to match new behavior:
- Mock API now returns error in errors array instead of empty merged_yaml
- Test expects 'most certainly not have a .gitlab-ci.yml file' message
- Matches actual GitLab API behavior when project has no CI/CD config

* Update src/pipeleak/pkg/gitlab/util/util.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: frjcomp <107982661+frjcomp@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 3 people

src/pipeleak/cmd/gitea/enum/enum.go

@@ -15,7 +15,6 @@ func NewEnumCmd() *cobra.Command {
 		Run:     Enum,
 	}
 
-
 	return enumCmd
 }
 

src/pipeleak/cmd/gitea/secrets/secrets.go

@@ -26,6 +26,5 @@ func NewSecretsCommand() *cobra.Command {
 		},
 	}
 
-
 	return cmd
 }

src/pipeleak/cmd/gitea/variables/variables.go

@@ -26,6 +26,5 @@ func NewVariablesCommand() *cobra.Command {
 		},
 	}
 
-
 	return cmd
 }

src/pipeleak/pkg/bitbucket/url/builder_test.go

@@ -1,8 +1,8 @@
 package url
 
 import (
-	"testing"
 	"strings"
+	"testing"
 
 	"github.com/stretchr/testify/assert"
 )

src/pipeleak/pkg/docs/generator_test.go

@@ -1,159 +1,159 @@
 package docs
 
 import (
-    "os"
-    "path/filepath"
-    "testing"
+	"os"
+	"path/filepath"
+	"testing"
 
-    "github.com/spf13/cobra"
-    "github.com/stretchr/testify/assert"
-    "gopkg.in/yaml.v3"
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v3"
 )
 
 // Test getFileName logic for level handling and GroupID usage.
 func TestGetFileName(t *testing.T) {
-    cmdNoGroup := &cobra.Command{Use: "scan", Short: "scan"}
-    cmdGroup := &cobra.Command{Use: "enum", GroupID: "enumeration"}
+	cmdNoGroup := &cobra.Command{Use: "scan", Short: "scan"}
+	cmdGroup := &cobra.Command{Use: "enum", GroupID: "enumeration"}
 
-    assert.Equal(t, "scan.md", getFileName(cmdNoGroup, 1))
-    assert.Equal(t, "enumeration.md", getFileName(cmdGroup, 1))
-    assert.Equal(t, "scan.md", getFileName(cmdNoGroup, 2)) // level >1 ignores GroupID logic
+	assert.Equal(t, "scan.md", getFileName(cmdNoGroup, 1))
+	assert.Equal(t, "enumeration.md", getFileName(cmdGroup, 1))
+	assert.Equal(t, "scan.md", getFileName(cmdNoGroup, 2)) // level >1 ignores GroupID logic
 }
 
 // Test displayName title casing and GroupID preference.
 func TestDisplayName(t *testing.T) {
-    cmdNoGroup := &cobra.Command{Use: "list"}
-    cmdGroup := &cobra.Command{Use: "enum", GroupID: "gitlab pentest"}
+	cmdNoGroup := &cobra.Command{Use: "list"}
+	cmdGroup := &cobra.Command{Use: "enum", GroupID: "gitlab pentest"}
 
-    assert.Equal(t, "List", displayName(cmdNoGroup, 1))
-    assert.Equal(t, "Gitlab Pentest", displayName(cmdGroup, 1)) // Title case applied
-    assert.Equal(t, "Enum", displayName(cmdGroup, 2))           // deeper level uses Name
+	assert.Equal(t, "List", displayName(cmdNoGroup, 1))
+	assert.Equal(t, "Gitlab Pentest", displayName(cmdGroup, 1)) // Title case applied
+	assert.Equal(t, "Enum", displayName(cmdGroup, 2))           // deeper level uses Name
 }
 
 // buildNav should create index.md for commands with children and .md file for leaves.
 func TestBuildNav(t *testing.T) {
-    root := &cobra.Command{Use: "pipeleak"}
-    parent := &cobra.Command{Use: "alpha"}
-    leaf := &cobra.Command{Use: "scan", Run: func(cmd *cobra.Command, args []string) {}}
-    parent.AddCommand(leaf)
-    root.AddCommand(parent)
-
-    entry := buildNav(root, 0, "")
-    assert.Equal(t, "Pipeleak", entry.Label)
-    assert.Len(t, entry.Children, 1)
-    child := entry.Children[0]
-    assert.Equal(t, "Alpha", child.Label)
-    assert.Equal(t, filepath.ToSlash("pipeleak/alpha/index.md"), child.FilePath)
-    assert.Len(t, child.Children, 1)
-    grand := child.Children[0]
-    assert.Equal(t, filepath.ToSlash("pipeleak/alpha/scan.md"), grand.FilePath)
+	root := &cobra.Command{Use: "pipeleak"}
+	parent := &cobra.Command{Use: "alpha"}
+	leaf := &cobra.Command{Use: "scan", Run: func(cmd *cobra.Command, args []string) {}}
+	parent.AddCommand(leaf)
+	root.AddCommand(parent)
+
+	entry := buildNav(root, 0, "")
+	assert.Equal(t, "Pipeleak", entry.Label)
+	assert.Len(t, entry.Children, 1)
+	child := entry.Children[0]
+	assert.Equal(t, "Alpha", child.Label)
+	assert.Equal(t, filepath.ToSlash("pipeleak/alpha/index.md"), child.FilePath)
+	assert.Len(t, child.Children, 1)
+	grand := child.Children[0]
+	assert.Equal(t, filepath.ToSlash("pipeleak/alpha/scan.md"), grand.FilePath)
 }
 
 // convertNavToYaml should trim pipeleak/ prefix and .md suffix.
 func TestConvertNavToYaml(t *testing.T) {
-    entries := []*NavEntry{
-        {Label: "Alpha", FilePath: filepath.ToSlash("pipeleak/alpha/index.md"), Children: []*NavEntry{}},
-        {Label: "Beta", FilePath: filepath.ToSlash("pipeleak/beta/leaf.md"), Children: []*NavEntry{}},
-    }
-    yamlList := convertNavToYaml(entries)
-    // Entries become maps with label key
-    assert.Len(t, yamlList, 2)
-    // Validate trimming and removal of extension
-    alphaMap := yamlList[0]
-    betaMap := yamlList[1]
-    assert.Equal(t, "alpha/index", alphaMap["Alpha"])
-    assert.Equal(t, "beta/leaf", betaMap["Beta"])
+	entries := []*NavEntry{
+		{Label: "Alpha", FilePath: filepath.ToSlash("pipeleak/alpha/index.md"), Children: []*NavEntry{}},
+		{Label: "Beta", FilePath: filepath.ToSlash("pipeleak/beta/leaf.md"), Children: []*NavEntry{}},
+	}
+	yamlList := convertNavToYaml(entries)
+	// Entries become maps with label key
+	assert.Len(t, yamlList, 2)
+	// Validate trimming and removal of extension
+	alphaMap := yamlList[0]
+	betaMap := yamlList[1]
+	assert.Equal(t, "alpha/index", alphaMap["Alpha"])
+	assert.Equal(t, "beta/leaf", betaMap["Beta"])
 }
 
 // writeMkdocsYaml should create mkdocs.yml with expected keys and nav entries.
 func TestWriteMkdocsYaml(t *testing.T) {
-    root := &cobra.Command{Use: "pipeleak"}
-    alpha := &cobra.Command{Use: "alpha", Run: func(cmd *cobra.Command, args []string) {}}
-    deepParent := &cobra.Command{Use: "beta"}
-    deepChild := &cobra.Command{Use: "deep", Run: func(cmd *cobra.Command, args []string) {}}
-    deepParent.AddCommand(deepChild)
-    root.AddCommand(alpha)
-    root.AddCommand(deepParent)
-
-    tmpDir := t.TempDir()
-    // Change working directory to module root (src/pipeleak) so relative ../../docs resolves correctly
-    wd, _ := os.Getwd()
-    rootDir := filepath.Clean(filepath.Join(wd, "..", ".."))
-    old := wd
-    if err := os.Chdir(rootDir); err != nil {
-        t.Fatalf("failed to chdir to root: %v", err)
-    }
-    defer func() { _ = os.Chdir(old) }()
-
-    err := writeMkdocsYaml(root, tmpDir, false)
-    assert.NoError(t, err)
-
-    data, err := os.ReadFile(filepath.Join(tmpDir, "mkdocs.yml"))
-    assert.NoError(t, err)
-
-    var parsed map[string]interface{}
-    err = yaml.Unmarshal(data, &parsed)
-    assert.NoError(t, err)
-
-    // Basic keys exist
-    assert.Equal(t, "Pipeleak - Pipeline Secrets Scanner", parsed["site_name"])
-    assert.Equal(t, "pipeleak", parsed["docs_dir"])
-
-    // Nav structure assertions
-    navAny, ok := parsed["nav"].([]interface{})
-    assert.True(t, ok)
-    assert.Equal(t, 4, len(navAny)) // intro, methodology, alpha, beta
-
-    // Introduction entry first
-    introMap, ok := navAny[0].(map[string]interface{})
-    assert.True(t, ok)
-    assert.Contains(t, introMap, "Introduction")
-    assert.Equal(t, "/introduction/getting_started/", introMap["Introduction"])
-
-    // Methodology second
-    methMap, ok := navAny[1].(map[string]interface{})
-    assert.True(t, ok)
-    assert.Contains(t, methMap, "Methodology")
-
-    // Command entries appear after methodology
-    foundAlpha := false
-    foundBeta := false
-    for _, item := range navAny[2:] {
-        if m, ok := item.(map[string]interface{}); ok {
-            if _, ok := m["Alpha"]; ok {
-                foundAlpha = true
-            }
-            if _, ok := m["Beta"]; ok {
-                foundBeta = true
-            }
-        }
-    }
-    assert.True(t, foundAlpha)
-    assert.True(t, foundBeta)
+	root := &cobra.Command{Use: "pipeleak"}
+	alpha := &cobra.Command{Use: "alpha", Run: func(cmd *cobra.Command, args []string) {}}
+	deepParent := &cobra.Command{Use: "beta"}
+	deepChild := &cobra.Command{Use: "deep", Run: func(cmd *cobra.Command, args []string) {}}
+	deepParent.AddCommand(deepChild)
+	root.AddCommand(alpha)
+	root.AddCommand(deepParent)
+
+	tmpDir := t.TempDir()
+	// Change working directory to module root (src/pipeleak) so relative ../../docs resolves correctly
+	wd, _ := os.Getwd()
+	rootDir := filepath.Clean(filepath.Join(wd, "..", ".."))
+	old := wd
+	if err := os.Chdir(rootDir); err != nil {
+		t.Fatalf("failed to chdir to root: %v", err)
+	}
+	defer func() { _ = os.Chdir(old) }()
+
+	err := writeMkdocsYaml(root, tmpDir, false)
+	assert.NoError(t, err)
+
+	data, err := os.ReadFile(filepath.Join(tmpDir, "mkdocs.yml"))
+	assert.NoError(t, err)
+
+	var parsed map[string]interface{}
+	err = yaml.Unmarshal(data, &parsed)
+	assert.NoError(t, err)
+
+	// Basic keys exist
+	assert.Equal(t, "Pipeleak - Pipeline Secrets Scanner", parsed["site_name"])
+	assert.Equal(t, "pipeleak", parsed["docs_dir"])
+
+	// Nav structure assertions
+	navAny, ok := parsed["nav"].([]interface{})
+	assert.True(t, ok)
+	assert.Equal(t, 4, len(navAny)) // intro, methodology, alpha, beta
+
+	// Introduction entry first
+	introMap, ok := navAny[0].(map[string]interface{})
+	assert.True(t, ok)
+	assert.Contains(t, introMap, "Introduction")
+	assert.Equal(t, "/introduction/getting_started/", introMap["Introduction"])
+
+	// Methodology second
+	methMap, ok := navAny[1].(map[string]interface{})
+	assert.True(t, ok)
+	assert.Contains(t, methMap, "Methodology")
+
+	// Command entries appear after methodology
+	foundAlpha := false
+	foundBeta := false
+	for _, item := range navAny[2:] {
+		if m, ok := item.(map[string]interface{}); ok {
+			if _, ok := m["Alpha"]; ok {
+				foundAlpha = true
+			}
+			if _, ok := m["Beta"]; ok {
+				foundBeta = true
+			}
+		}
+	}
+	assert.True(t, foundAlpha)
+	assert.True(t, foundBeta)
 }
 
 // writeMkdocsYaml with GithubPages should prefix nav paths.
 func TestWriteMkdocsYaml_GithubPagesPrefix(t *testing.T) {
-    root := &cobra.Command{Use: "pipeleak"}
-    root.AddCommand(&cobra.Command{Use: "alpha", Run: func(cmd *cobra.Command, args []string) {}})
-
-    tmpDir := t.TempDir()
-    wd, _ := os.Getwd()
-    rootDir := filepath.Clean(filepath.Join(wd, "..", ".."))
-    old := wd
-    if err := os.Chdir(rootDir); err != nil {
-        t.Fatalf("failed to chdir to root: %v", err)
-    }
-    defer func() { _ = os.Chdir(old) }()
-
-    err := writeMkdocsYaml(root, tmpDir, true)
-    assert.NoError(t, err)
-    data, err := os.ReadFile(filepath.Join(tmpDir, "mkdocs.yml"))
-    assert.NoError(t, err)
-    var parsed map[string]interface{}
-    err = yaml.Unmarshal(data, &parsed)
-    assert.NoError(t, err)
-    navAny := parsed["nav"].([]interface{})
-    introMap := navAny[0].(map[string]interface{})
-    assert.Equal(t, "/pipeleak/introduction/getting_started/", introMap["Introduction"])
+	root := &cobra.Command{Use: "pipeleak"}
+	root.AddCommand(&cobra.Command{Use: "alpha", Run: func(cmd *cobra.Command, args []string) {}})
+
+	tmpDir := t.TempDir()
+	wd, _ := os.Getwd()
+	rootDir := filepath.Clean(filepath.Join(wd, "..", ".."))
+	old := wd
+	if err := os.Chdir(rootDir); err != nil {
+		t.Fatalf("failed to chdir to root: %v", err)
+	}
+	defer func() { _ = os.Chdir(old) }()
+
+	err := writeMkdocsYaml(root, tmpDir, true)
+	assert.NoError(t, err)
+	data, err := os.ReadFile(filepath.Join(tmpDir, "mkdocs.yml"))
+	assert.NoError(t, err)
+	var parsed map[string]interface{}
+	err = yaml.Unmarshal(data, &parsed)
+	assert.NoError(t, err)
+	navAny := parsed["nav"].([]interface{})
+	introMap := navAny[0].(map[string]interface{})
+	assert.Equal(t, "/pipeleak/introduction/getting_started/", introMap["Introduction"])
 }

src/pipeleak/pkg/gitlab/renovate/autodiscovery/autodiscovery.go

@@ -1,8 +1,8 @@
 package renovate
 
 import (
-	"github.com/CompassSecurity/pipeleak/pkg/gitlab/util"
 	"github.com/CompassSecurity/pipeleak/pkg/format"
+	"github.com/CompassSecurity/pipeleak/pkg/gitlab/util"
 	"github.com/rs/zerolog/log"
 	gogitlab "gitlab.com/gitlab-org/api/client-go"
 )

src/pipeleak/pkg/gitlab/renovate/enum/enum.go

@@ -11,8 +11,8 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/CompassSecurity/pipeleak/pkg/gitlab/util"
 	"github.com/CompassSecurity/pipeleak/pkg/format"
+	"github.com/CompassSecurity/pipeleak/pkg/gitlab/util"
 	"github.com/CompassSecurity/pipeleak/pkg/httpclient"
 	"github.com/rs/zerolog/log"
 	"github.com/yosuke-furukawa/json5/encoding/json5"

src/pipeleak/pkg/gitlab/runners/list/list_test.go

@@ -181,9 +181,9 @@ func TestFormatRunnerInfo(t *testing.T) {
 				return
 			}
 
-		require.NotNil(t, info)
-		assert.Equal(t, int(tt.details.ID), info.ID)
-		assert.Equal(t, tt.details.Name, info.Name)
+			require.NotNil(t, info)
+			assert.Equal(t, int(tt.details.ID), info.ID)
+			assert.Equal(t, tt.details.Name, info.Name)
 			assert.Equal(t, tt.details.Description, info.Description)
 			assert.Equal(t, tt.details.RunnerType, info.Type)
 			assert.Equal(t, tt.details.Paused, info.Paused)

src/pipeleak/pkg/gitlab/schedule/schedule.go

@@ -65,7 +65,7 @@ func ListPipelineSchedules(git *gitlab.Client, project *gitlab.Project) {
 
 		for _, schedule := range schedules {
 			scheduleWithVars, _, err := git.PipelineSchedules.GetPipelineSchedule(project.ID, schedule.ID)
-				if err != nil {
+			if err != nil {
 				log.Error().Stack().Err(err).Int64("project", project.ID).Msg("Failed fetching schedule variables")
 				continue
 			}

src/pipeleak/pkg/gitlab/util/util.go

@@ -207,6 +207,15 @@ func FetchCICDYml(git *gitlab.Client, pid int64) (string, error) {
 		return "", err
 	}
 
+	for _, msg := range res.Errors {
+		log.Debug().Str("type", msg).Msg("Validation error of gitlab-ci.yml in project")
+
+		// API does not distinguish between missing file and actual errors in the YAML
+		if strings.Contains(msg, "Please provide content of") {
+			return "", errors.New("project does most certainly not have a .gitlab-ci.yml file")
+		}
+	}
+
 	if len(res.Errors) > 0 {
 		return "", errors.New(strings.Join(res.Errors, ", "))
 	}