gitea/modules/setting/actions_test.go

// Copyright 2023 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT

package setting

import (
	"path/filepath"
	"slices"
	"testing"

	"gitea.dev/modules/test"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func Test_getStorageInheritNameSectionTypeForActions(t *testing.T) {
	for _, tc := range []struct {
		iniStr, logType, artifactType string
	}{
		{`
	[storage]
	STORAGE_TYPE = minio
	`, "minio", "minio"},
		{`
[storage.actions_log]
STORAGE_TYPE = minio
`, "minio", "local"},
		{`
[storage.actions_log]
STORAGE_TYPE = my_storage

[storage.my_storage]
STORAGE_TYPE = minio
`, "minio", "local"},
		{`
[storage.actions_artifacts]
STORAGE_TYPE = my_storage

[storage.my_storage]
STORAGE_TYPE = minio
`, "local", "minio"},
		{`
[storage.actions_artifacts]
STORAGE_TYPE = my_storage

[storage.my_storage]
STORAGE_TYPE = minio
`, "local", "minio"},
		{``, "local", "local"},
	} {
		cfg, err := NewConfigProviderFromData(tc.iniStr)
		assert.NoError(t, err)
		assert.NoError(t, loadActionsFrom(cfg))

		assert.EqualValues(t, tc.logType, Actions.LogStorage.Type)
		if tc.logType == "minio" {
			assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
		} else {
			assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
		}
		assert.EqualValues(t, tc.artifactType, Actions.ArtifactStorage.Type)
		if tc.artifactType == "minio" {
			assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
		} else {
			assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
		}
	}
}

func Test_WorkflowDirs(t *testing.T) {
	oldActions := Actions
	defer func() {
		Actions = oldActions
	}()

	tests := []struct {
		name     string
		iniStr   string
		wantDirs []string
		wantErr  bool
	}{
		{
			name:     "default",
			iniStr:   `[actions]`,
			wantDirs: []string{".gitea/workflows", ".github/workflows"},
		},
		{
			name:     "single dir",
			iniStr:   "[actions]\nWORKFLOW_DIRS = .github/workflows",
			wantDirs: []string{".github/workflows"},
		},
		{
			name:     "custom order",
			iniStr:   "[actions]\nWORKFLOW_DIRS = .github/workflows,.gitea/workflows",
			wantDirs: []string{".github/workflows", ".gitea/workflows"},
		},
		{
			name:     "whitespace trimming",
			iniStr:   "[actions]\nWORKFLOW_DIRS = .gitea/workflows , .github/workflows ",
			wantDirs: []string{".gitea/workflows", ".github/workflows"},
		},
		{
			name:     "trailing slash normalization",
			iniStr:   "[actions]\nWORKFLOW_DIRS = .gitea/workflows/,.github/workflows/",
			wantDirs: []string{".gitea/workflows", ".github/workflows"},
		},
		{
			name:    "only commas and whitespace",
			iniStr:  "[actions]\nWORKFLOW_DIRS = , , ,",
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cfg, err := NewConfigProviderFromData(tt.iniStr)
			require.NoError(t, err)
			err = loadActionsFrom(cfg)
			if tt.wantErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)
			assert.Equal(t, tt.wantDirs, Actions.WorkflowDirs)
		})
	}
}

func Test_getDefaultActionsURLForActions(t *testing.T) {
	oldActions := Actions
	oldAppURL := AppURL
	defer func() {
		Actions = oldActions
		AppURL = oldAppURL
	}()

	AppURL = "http://test_get_default_actions_url_for_actions:3000/"

	tests := []struct {
		name    string
		iniStr  string
		wantErr assert.ErrorAssertionFunc
		wantURL string
	}{
		{
			name: "default",
			iniStr: `
[actions]
`,
			wantErr: assert.NoError,
			wantURL: "https://github.com",
		},
		{
			name: "github",
			iniStr: `
[actions]
DEFAULT_ACTIONS_URL = github
`,
			wantErr: assert.NoError,
			wantURL: "https://github.com",
		},
		{
			name: "self",
			iniStr: `
[actions]
DEFAULT_ACTIONS_URL = self
`,
			wantErr: assert.NoError,
			wantURL: "http://test_get_default_actions_url_for_actions:3000",
		},
		{
			name: "custom url",
			iniStr: `
[actions]
DEFAULT_ACTIONS_URL = https://gitea.com
`,
			wantErr: assert.NoError,
			wantURL: "https://github.com",
		},
		{
			name: "custom urls",
			iniStr: `
[actions]
DEFAULT_ACTIONS_URL = https://gitea.com,https://github.com
`,
			wantErr: assert.NoError,
			wantURL: "https://github.com",
		},
		{
			name: "invalid",
			iniStr: `
[actions]
DEFAULT_ACTIONS_URL = gitea
`,
			wantErr: assert.Error,
			wantURL: "https://github.com",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cfg, err := NewConfigProviderFromData(tt.iniStr)
			require.NoError(t, err)
			if !tt.wantErr(t, loadActionsFrom(cfg)) {
				return
			}
			assert.Equal(t, tt.wantURL, Actions.DefaultActionsURL.URL())
		})
	}
}

func Test_ScopedWorkflowDirs(t *testing.T) {
	defer test.MockVariableValue(&Actions)()

	defaultWorkflowDirs := []string{".gitea/workflows", ".github/workflows"}
	defaultScopedDirs := []string{".gitea/scoped_workflows"}

	tests := []struct {
		name       string
		iniStr     string
		wantScoped []string
		wantErr    bool
	}{
		{
			name:       "default",
			iniStr:     `[actions]`,
			wantScoped: defaultScopedDirs,
		},
		{
			name:       "custom dir",
			iniStr:     "[actions]\nSCOPED_WORKFLOW_DIRS = .gitea/my-scoped",
			wantScoped: []string{".gitea/my-scoped"},
		},
		{
			name:       "empty disables the feature",
			iniStr:     "[actions]\nSCOPED_WORKFLOW_DIRS = , ,",
			wantScoped: []string{},
		},
		{
			name:    "overlap equal with workflow dir",
			iniStr:  "[actions]\nWORKFLOW_DIRS = .gitea/workflows\nSCOPED_WORKFLOW_DIRS = .gitea/workflows",
			wantErr: true,
		},
		{
			name:    "scoped dir nested under workflow dir",
			iniStr:  "[actions]\nWORKFLOW_DIRS = .gitea/workflows\nSCOPED_WORKFLOW_DIRS = .gitea/workflows/scoped",
			wantErr: true,
		},
		{
			name:    "workflow dir nested under scoped dir",
			iniStr:  "[actions]\nWORKFLOW_DIRS = .gitea/workflows/ci\nSCOPED_WORKFLOW_DIRS = .gitea/workflows",
			wantErr: true,
		},
		{
			name:       "no overlap",
			iniStr:     "[actions]\nSCOPED_WORKFLOW_DIRS = .gitea/scoped",
			wantScoped: []string{".gitea/scoped"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// reset to defaults so MapTo starts clean (absent keys keep the defaults)
			Actions.WorkflowDirs = slices.Clone(defaultWorkflowDirs)
			Actions.ScopedWorkflowDirs = slices.Clone(defaultScopedDirs)

			cfg, err := NewConfigProviderFromData(tt.iniStr)
			require.NoError(t, err)
			err = loadActionsFrom(cfg)
			if tt.wantErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)
			assert.Equal(t, tt.wantScoped, Actions.ScopedWorkflowDirs)
		})
	}
}