fix: GitLab provider getting a URL on same host

Refactored the GitLab provider to correctly handle project IDs and fetch
raw files with our token. We were fetching the URL as is when there are
URLs don't work like GitHub which allows passing a token and getting a
private raw URL directly.

Jira: https://issues.redhat.com/browse/SRVKP-7357
AI-assisted-by: Google Gemini 3
Signed-off-by: Chmouel Boudjnah <[email protected]>

Author: chmouel

pkg/provider/gitlab/task.go

@@ -2,15 +2,18 @@ package gitlab
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/url"
 	"regexp"
 
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/params/info"
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/provider"
+	gl "gitlab.com/gitlab-org/api/client-go"
 )
 
 type gitLabInfo struct {
+	Scheme      string
 	Host        string
 	GroupOrUser string
 	Repository  string
@@ -55,6 +58,7 @@ func extractGitLabInfo(gitlabURL string) (*gitLabInfo, error) {
 	}
 
 	return &gitLabInfo{
+		Scheme:      parsedURL.Scheme,
 		Host:        parsedURL.Host,
 		GroupOrUser: groupOrUser,
 		Repository:  repoName,
@@ -65,7 +69,7 @@ func extractGitLabInfo(gitlabURL string) (*gitLabInfo, error) {
 
 // GetTaskURI if we are getting a URL from the same URL where the provider is,
 // it means we can try to get the file with the provider token.
-func (v *Provider) GetTaskURI(ctx context.Context, event *info.Event, uri string) (bool, string, error) {
+func (v *Provider) GetTaskURI(_ context.Context, event *info.Event, uri string) (bool, string, error) {
 	if ret := provider.CompareHostOfURLS(uri, event.URL); !ret {
 		return false, "", nil
 	}
@@ -74,13 +78,40 @@ func (v *Provider) GetTaskURI(ctx context.Context, event *info.Event, uri string
 		return false, "", err
 	}
 
-	nEvent := info.NewEvent()
-	nEvent.Organization = extracted.GroupOrUser
-	nEvent.Repository = extracted.Repository
-	nEvent.BaseBranch = extracted.Revision
-	ret, err := v.GetFileInsideRepo(ctx, nEvent, extracted.FilePath, extracted.Revision)
+	// Use the existing client if available, otherwise create a temporary one.
+	// We avoid storing it to prevent side effects on the provider's state.
+	client := v.gitlabClient
+	if client == nil {
+		baseURL := fmt.Sprintf("%s://%s", extracted.Scheme, extracted.Host)
+		var clientErr error
+		client, clientErr = gl.NewClient(event.Provider.Token, gl.WithBaseURL(baseURL))
+		if clientErr != nil {
+			return false, "", fmt.Errorf("failed to create gitlab client: %w", clientErr)
+		}
+	}
+
+	// Construct the project slug for the remote repository
+	projectSlug := extracted.GroupOrUser + "/" + extracted.Repository
+
+	// Get the project ID for the remote repository
+	project, _, err := client.Projects.GetProject(projectSlug, &gl.GetProjectOptions{})
 	if err != nil {
-		return false, "", err
+		if errors.Is(err, gl.ErrNotFound) {
+			return false, "", nil
+		}
+		return false, "", fmt.Errorf("failed to get project ID for %s: %w", projectSlug, err)
+	}
+
+	// Fetch the file from the remote repository
+	opt := &gl.GetRawFileOptions{
+		Ref: gl.Ptr(extracted.Revision),
+	}
+	file, _, err := client.RepositoryFiles.GetRawFile(project.ID, extracted.FilePath, opt)
+	if err != nil {
+		if errors.Is(err, gl.ErrNotFound) {
+			return false, "", nil
+		}
+		return false, "", fmt.Errorf("failed to get file %s from remote repository: %w", extracted.FilePath, err)
 	}
-	return true, ret, nil
+	return true, string(file), nil
 }

pkg/provider/gitlab/task_test.go

@@ -1,8 +1,14 @@
 package gitlab
 
 import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
 	"testing"
 
+	"github.com/openshift-pipelines/pipelines-as-code/pkg/params/info"
+	gl "gitlab.com/gitlab-org/api/client-go"
 	"gotest.tools/v3/assert"
 )
 
@@ -16,6 +22,7 @@ func TestExtractGitLabInfo(t *testing.T) {
 			name: "custom host",
 			url:  "https://gitlab.chmouel.com/group/subgroup/repo/-/blob/main/README.md?ref_type=heads",
 			expected: &gitLabInfo{
+				Scheme:      "https",
 				Host:        "gitlab.chmouel.com",
 				GroupOrUser: "group/subgroup",
 				Repository:  "repo",
@@ -27,6 +34,7 @@ func TestExtractGitLabInfo(t *testing.T) {
 			name: "org repo",
 			url:  "https://gitlab.com/org/repo/-/blob/main/README.md",
 			expected: &gitLabInfo{
+				Scheme:      "https",
 				Host:        "gitlab.com",
 				GroupOrUser: "org",
 				Repository:  "repo",
@@ -38,6 +46,7 @@ func TestExtractGitLabInfo(t *testing.T) {
 			name: "long group and subgroups",
 			url:  "https://gitlab.com/gitlab-com/partners/alliance/corp/sandbox/another/foo-foo/-/raw/main/hello.txt?ref_type=heads",
 			expected: &gitLabInfo{
+				Scheme:      "https",
 				Host:        "gitlab.com",
 				GroupOrUser: "gitlab-com/partners/alliance/corp/sandbox/another",
 				Repository:  "foo-foo",
@@ -55,3 +64,178 @@ func TestExtractGitLabInfo(t *testing.T) {
 		})
 	}
 }
+
+func TestGetTaskURI(t *testing.T) {
+	ctx := context.Background()
+	expectedContent := "apiVersion: tekton.dev/v1beta1\nkind: Pipeline\nmetadata:\n  name: test-pipeline\nspec:\n  tasks:\n    - name: echo-task\n      taskSpec:\n        steps:\n          - name: echo\n            image: ubuntu\n            script: |\n              echo \"Hello from remote pipeline!\"\n"
+
+	tests := []struct {
+		name            string
+		setup           func(t *testing.T) (*httptest.Server, string, string)
+		wantFound       bool
+		wantErr         bool
+		wantErrContains string
+		wantContent     string
+	}{
+		{
+			name: "success",
+			setup: func(t *testing.T) (*httptest.Server, string, string) {
+				projectID := 12345
+				projectSlug := "chmouel/dazgo"
+				revision := "main"
+				filePath := "task.yaml"
+
+				mux := http.NewServeMux()
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%s", gl.PathEscape(projectSlug)), func(w http.ResponseWriter, _ *http.Request) {
+					fmt.Fprintf(w, `{"id": %d, "path_with_namespace": "%s"}`, projectID, projectSlug)
+				})
+
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%d/repository/files/%s/raw", projectID, gl.PathEscape(filePath)), func(w http.ResponseWriter, r *http.Request) {
+					assert.Equal(t, "token", r.Header.Get("Private-Token"), "Expected Private-Token header to be 'token'")
+					assert.Equal(t, revision, r.URL.Query().Get("ref"), "Expected 'ref' query parameter to be 'main'")
+					fmt.Fprint(w, expectedContent)
+				})
+
+				server := httptest.NewServer(mux)
+				remotePipelineURL := fmt.Sprintf("%s/%s/-/raw/%s/%s", server.URL, projectSlug, revision, filePath)
+				return server, server.URL, remotePipelineURL
+			},
+			wantFound:   true,
+			wantErr:     false,
+			wantContent: expectedContent,
+		},
+		{
+			name: "file not found (404)",
+			setup: func(_ *testing.T) (*httptest.Server, string, string) {
+				mux := http.NewServeMux()
+				projectID := 12345
+				projectSlug := "chmouel/dazgo"
+				filePath := "nonexistent.yaml"
+
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%s", gl.PathEscape(projectSlug)), func(w http.ResponseWriter, _ *http.Request) {
+					fmt.Fprintf(w, `{"id": %d, "path_with_namespace": "%s"}`, projectID, projectSlug)
+				})
+
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%d/repository/files/%s/raw", projectID, gl.PathEscape(filePath)), func(w http.ResponseWriter, _ *http.Request) {
+					w.WriteHeader(http.StatusNotFound)
+					fmt.Fprint(w, `{"message": "404 File Not Found"}`)
+				})
+
+				server := httptest.NewServer(mux)
+				remotePipelineURL := fmt.Sprintf("%s/%s/-/raw/main/%s", server.URL, projectSlug, filePath)
+				return server, server.URL, remotePipelineURL
+			},
+			wantFound: false,
+			wantErr:   false,
+		},
+		{
+			name: "project not found (404)",
+			setup: func(_ *testing.T) (*httptest.Server, string, string) {
+				mux := http.NewServeMux()
+				projectSlug := "nonexistent/project"
+
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%s", gl.PathEscape(projectSlug)), func(w http.ResponseWriter, _ *http.Request) {
+					w.WriteHeader(http.StatusNotFound)
+					fmt.Fprint(w, `{"message": "404 Project Not Found"}`)
+				})
+
+				server := httptest.NewServer(mux)
+				remotePipelineURL := fmt.Sprintf("%s/%s/-/raw/main/task.yaml", server.URL, projectSlug)
+				return server, server.URL, remotePipelineURL
+			},
+			wantFound: false,
+			wantErr:   false,
+		},
+		{
+			name: "invalid gitlab URL format",
+			setup: func(_ *testing.T) (*httptest.Server, string, string) {
+				return nil, "https://example.com", "https://example.com/invalid/url/format"
+			},
+			wantFound:       false,
+			wantErr:         true,
+			wantErrContains: "URL does not match the expected GitLab pattern",
+		},
+		{
+			name: "different host - should return not found",
+			setup: func(_ *testing.T) (*httptest.Server, string, string) {
+				return nil, "https://gitlab.com", "https://different-host.com/chmouel/dazgo/-/raw/main/task.yaml"
+			},
+			wantFound: false,
+			wantErr:   false,
+		},
+		{
+			name: "API error on GetProject",
+			setup: func(_ *testing.T) (*httptest.Server, string, string) {
+				mux := http.NewServeMux()
+				projectSlug := "chmouel/dazgo"
+
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%s", gl.PathEscape(projectSlug)), func(w http.ResponseWriter, _ *http.Request) {
+					w.WriteHeader(http.StatusInternalServerError)
+					fmt.Fprint(w, `{"message": "Internal Server Error"}`)
+				})
+
+				server := httptest.NewServer(mux)
+				remotePipelineURL := fmt.Sprintf("%s/%s/-/raw/main/task.yaml", server.URL, projectSlug)
+				return server, server.URL, remotePipelineURL
+			},
+			wantFound:       false,
+			wantErr:         true,
+			wantErrContains: "failed to get project ID",
+		},
+		{
+			name: "API error on GetRawFile",
+			setup: func(_ *testing.T) (*httptest.Server, string, string) {
+				mux := http.NewServeMux()
+				projectID := 12345
+				projectSlug := "chmouel/dazgo"
+				filePath := "task.yaml"
+
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%s", gl.PathEscape(projectSlug)), func(w http.ResponseWriter, _ *http.Request) {
+					fmt.Fprintf(w, `{"id": %d, "path_with_namespace": "%s"}`, projectID, projectSlug)
+				})
+
+				mux.HandleFunc(fmt.Sprintf("/api/v4/projects/%d/repository/files/%s/raw", projectID, gl.PathEscape(filePath)), func(w http.ResponseWriter, _ *http.Request) {
+					w.WriteHeader(http.StatusInternalServerError)
+					fmt.Fprint(w, `{"message": "Internal Server Error"}`)
+				})
+
+				server := httptest.NewServer(mux)
+				remotePipelineURL := fmt.Sprintf("%s/%s/-/raw/main/%s", server.URL, projectSlug, filePath)
+				return server, server.URL, remotePipelineURL
+			},
+			wantFound:       false,
+			wantErr:         true,
+			wantErrContains: "failed to get file",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server, eventURL, remotePipelineURL := tt.setup(t)
+			if server != nil {
+				defer server.Close()
+			}
+
+			v := &Provider{}
+			event := info.NewEvent()
+			event.URL = eventURL
+			event.Provider = &info.Provider{
+				Token: "token",
+			}
+
+			found, content, err := v.GetTaskURI(ctx, event, remotePipelineURL)
+
+			if tt.wantErr {
+				assert.Assert(t, err != nil, "expected error but got nil")
+				if tt.wantErrContains != "" {
+					assert.ErrorContains(t, err, tt.wantErrContains)
+				}
+			} else {
+				assert.NilError(t, err)
+			}
+
+			assert.Equal(t, tt.wantFound, found)
+			assert.Equal(t, tt.wantContent, content)
+		})
+	}
+}