python_test.go

// Copyright 2022-2026 Salesforce, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package python

import (
	"encoding/json"
	"fmt"
	"path/filepath"
	"runtime"
	"testing"

	"github.com/slackapi/slack-cli/internal/config"
	"github.com/slackapi/slack-cli/internal/hooks"
	"github.com/slackapi/slack-cli/internal/iostreams"
	"github.com/slackapi/slack-cli/internal/shared/types"
	"github.com/slackapi/slack-cli/internal/slackcontext"
	"github.com/slackapi/slack-cli/internal/slackdeps"
	"github.com/spf13/afero"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"
)

func Test_Python_New(t *testing.T) {
	tests := map[string]struct {
		expectedPython *Python
	}{
		"New Python instance": {
			expectedPython: &Python{},
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			p := New()
			require.Equal(t, tc.expectedPython, p)
		})
	}
}

func Test_Python_IgnoreDirectories(t *testing.T) {
	tests := map[string]struct {
		expectedIgnoreDirectories []string
	}{
		"No directories": {
			expectedIgnoreDirectories: []string{},
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			p := New()
			require.Equal(t, tc.expectedIgnoreDirectories, p.IgnoreDirectories())
		})
	}
}

func Test_getVenvPath(t *testing.T) {
	tests := map[string]struct {
		projectDirPath string
		expectedPath   string
	}{
		"Get venv path": {
			projectDirPath: "/path/to/project",
			expectedPath:   "/path/to/project/.venv",
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			result := getVenvPath(tc.projectDirPath)
			require.Equal(t, tc.expectedPath, result)
		})
	}
}

func Test_getPythonExecutable(t *testing.T) {
	tests := map[string]struct {
		expectedExecutable string
		onlyOnWindows      bool
	}{
		"Get python executable on Unix": {
			expectedExecutable: "python3",
			onlyOnWindows:      false,
		},
		"Get python executable on Windows": {
			expectedExecutable: "python",
			onlyOnWindows:      true,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			isWindows := runtime.GOOS == "windows"
			if tc.onlyOnWindows != isWindows {
				t.Skip("skipping test on " + runtime.GOOS)
			}
			result := getPythonExecutable()
			require.Equal(t, tc.expectedExecutable, result)
		})
	}
}

func Test_getPipExecutable(t *testing.T) {
	tests := map[string]struct {
		venvPath      string
		expectedPath  string
		onlyOnWindows bool
	}{
		"Get pip path on Unix": {
			venvPath:      "/path/to/.venv",
			expectedPath:  "/path/to/.venv/bin/pip",
			onlyOnWindows: false,
		},
		"Get pip path on Windows": {
			venvPath:      "C:\\path\\to\\.venv",
			expectedPath:  "C:\\path\\to\\.venv\\Scripts\\pip.exe",
			onlyOnWindows: true,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			isWindows := runtime.GOOS == "windows"
			if tc.onlyOnWindows != isWindows {
				t.Skip("skipping test on " + runtime.GOOS)
			}
			result := getPipExecutable(tc.venvPath)
			require.Equal(t, tc.expectedPath, result)
		})
	}
}

func Test_installRequirementsTxt(t *testing.T) {
	tests := map[string]struct {
		existingContent string
		expectedContent string
		expectedOutput  string
		expectedError   bool
	}{
		"Skip when slack-cli-hooks already exists": {
			existingContent: "slack-cli-hooks\npytest==8.3.2\nruff==0.7.2",
			expectedContent: "slack-cli-hooks\npytest==8.3.2\nruff==0.7.2",
			expectedOutput:  "Found requirements.txt with",
			expectedError:   false,
		},
		"Add after slack-bolt when it exists": {
			existingContent: "slack-bolt==2.31.2\npytest==8.3.2\nruff==0.7.2",
			expectedContent: "slack-bolt==2.31.2\nslack-cli-hooks<1.0.0\npytest==8.3.2\nruff==0.7.2",
			expectedOutput:  "Updated requirements.txt with",
			expectedError:   false,
		},
		"Add at end when slack-bolt doesn't exist": {
			existingContent: "pytest==8.3.2\nruff==0.7.2",
			expectedContent: "pytest==8.3.2\nruff==0.7.2\nslack-cli-hooks<1.0.0",
			expectedOutput:  "Updated requirements.txt with",
			expectedError:   false,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			fs := slackdeps.NewFsMock()
			projectDirPath := "/path/to/project"

			// Create requirements.txt
			requirementsPath := filepath.Join(projectDirPath, "requirements.txt")
			err := fs.MkdirAll(projectDirPath, 0755)
			require.NoError(t, err)
			err = afero.WriteFile(fs, requirementsPath, []byte(tc.existingContent), 0644)
			require.NoError(t, err)

			// Test
			output, err := installRequirementsTxt(fs, projectDirPath)

			// Assertions
			if tc.expectedError {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}

			require.Contains(t, output, tc.expectedOutput)

			// Verify file content
			content, err := afero.ReadFile(fs, requirementsPath)
			require.NoError(t, err)
			require.Equal(t, tc.expectedContent, string(content))
		})
	}
}

func Test_installPyProjectToml(t *testing.T) {
	tests := map[string]struct {
		existingContent string
		shouldContain   []string
		expectedOutput  string
		expectedError   bool
	}{
		"Skip when slack-cli-hooks already exists": {
			existingContent: `[project]
name = "my-app"
dependencies = ["slack-cli-hooks<1.0.0", "pytest==8.3.2"]`,
			shouldContain:  []string{"slack-cli-hooks"},
			expectedOutput: "Found pyproject.toml with",
			expectedError:  false,
		},
		"Add after slack-bolt when it exists": {
			existingContent: `[project]
name = "my-app"
dependencies = ["slack-bolt>=1.0.0", "pytest==8.3.2"]`,
			shouldContain:  []string{"slack-bolt", "slack-cli-hooks", "pytest"},
			expectedOutput: "Updated pyproject.toml with",
			expectedError:  false,
		},
		"Add at end when slack-bolt doesn't exist": {
			existingContent: `[project]
name = "my-app"
dependencies = ["pytest==8.3.2"]`,
			shouldContain:  []string{"slack-cli-hooks", "pytest"},
			expectedOutput: "Updated pyproject.toml with",
			expectedError:  false,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			ctx := slackcontext.MockContext(t.Context())
			fs := slackdeps.NewFsMock()
			os := slackdeps.NewOsMock()
			os.AddDefaultMocks()
			cfg := config.NewConfig(fs, os)
			ios := iostreams.NewIOStreamsMock(cfg, fs, os)
			ios.AddDefaultMocks()
			projectDirPath := "/path/to/project"

			// Create pyproject.toml
			pyprojectPath := filepath.Join(projectDirPath, "pyproject.toml")
			err := fs.MkdirAll(projectDirPath, 0755)
			require.NoError(t, err)
			err = afero.WriteFile(fs, pyprojectPath, []byte(tc.existingContent), 0644)
			require.NoError(t, err)

			// Test
			output, err := installPyProjectToml(ctx, ios, fs, projectDirPath)

			// Assertions
			if tc.expectedError {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}

			if tc.expectedOutput != "" {
				require.Contains(t, output, tc.expectedOutput)
			}

			// Verify file content contains expected strings
			content, err := afero.ReadFile(fs, pyprojectPath)
			require.NoError(t, err)
			for _, expected := range tc.shouldContain {
				require.Contains(t, string(content), expected)
			}
		})
	}
}

func Test_venvExists(t *testing.T) {
	tests := map[string]struct {
		venvPath       string
		createPipFile  bool
		expectedResult bool
	}{
		"Venv exists when pip file present": {
			venvPath:       "/path/to/.venv",
			createPipFile:  true,
			expectedResult: true,
		},
		"Venv does not exist when pip file absent": {
			venvPath:       "/path/to/.venv",
			createPipFile:  false,
			expectedResult: false,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			fs := slackdeps.NewFsMock()

			if tc.createPipFile {
				pipPath := getPipExecutable(tc.venvPath)
				err := fs.MkdirAll(filepath.Dir(pipPath), 0755)
				require.NoError(t, err)
				err = afero.WriteFile(fs, pipPath, []byte(""), 0755)
				require.NoError(t, err)
			}

			result := venvExists(fs, tc.venvPath)
			require.Equal(t, tc.expectedResult, result)
		})
	}
}

func Test_getVenvBinDir(t *testing.T) {
	result := getVenvBinDir("/path/to/.venv")
	if runtime.GOOS == "windows" {
		require.Equal(t, filepath.Join("/path/to/.venv", "Scripts"), result)
	} else {
		require.Equal(t, filepath.Join("/path/to/.venv", "bin"), result)
	}
}

func Test_ActivateVenvIfPresent(t *testing.T) {
	tests := map[string]struct {
		createVenv        bool
		expectedActivated bool
	}{
		"activates venv when it exists": {
			createVenv:        true,
			expectedActivated: true,
		},
		"no-op when venv does not exist": {
			createVenv:        false,
			expectedActivated: false,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			fs := slackdeps.NewFsMock()
			osMock := slackdeps.NewOsMock()
			projectDir := "/path/to/project"
			venvPath := filepath.Join(projectDir, ".venv")

			originalPath := "/usr/bin:/bin"
			osMock.On("Getenv", "PATH").Return(originalPath)
			osMock.AddDefaultMocks()

			if tc.createVenv {
				// Create the pip executable so venvExists returns true
				pipPath := getPipExecutable(venvPath)
				err := fs.MkdirAll(filepath.Dir(pipPath), 0755)
				require.NoError(t, err)
				err = afero.WriteFile(fs, pipPath, []byte(""), 0755)
				require.NoError(t, err)
			}

			activated, err := ActivateVenvIfPresent(fs, osMock, projectDir)
			require.NoError(t, err)
			require.Equal(t, tc.expectedActivated, activated)

			if tc.expectedActivated {
				expectedBinDir := getVenvBinDir(venvPath)
				osMock.AssertCalled(t, "Setenv", "VIRTUAL_ENV", venvPath)
				osMock.AssertCalled(t, "Setenv", "PATH", expectedBinDir+string(filepath.ListSeparator)+originalPath)
				osMock.AssertCalled(t, "Unsetenv", "PYTHONHOME")
			} else {
				osMock.AssertNotCalled(t, "Setenv", mock.Anything, mock.Anything)
				osMock.AssertNotCalled(t, "Unsetenv", mock.Anything)
			}
		})
	}
}

func Test_Python_InstallProjectDependencies(t *testing.T) {
	tests := map[string]struct {
		existingFiles      map[string]string
		expectedFiles      map[string]string
		expectedOutputs    []string
		notExpectedOutputs []string
		expectedError      bool
	}{
		"Error when requirements.txt is missing": {
			existingFiles:   map[string]string{}, // No files
			expectedOutputs: []string{"Error"},
			expectedError:   true,
		},
		"Skip when requirements.txt contains slack-cli-hooks": {
			existingFiles: map[string]string{
				"requirements.txt": "slack-cli-hooks\npytest==8.3.2\nruff==0.7.2",
			},
			expectedFiles: map[string]string{
				"requirements.txt": "slack-cli-hooks\npytest==8.3.2\nruff==0.7.2",
			},
			expectedOutputs: []string{"Found"},
			expectedError:   false,
		},
		"Skip when requirements.txt contains slack-cli-hooks<1.0.0": {
			existingFiles: map[string]string{
				"requirements.txt": "slack-cli-hooks<1.0.0\npytest==8.3.2\nruff==0.7.2",
			},
			expectedFiles: map[string]string{
				"requirements.txt": "slack-cli-hooks<1.0.0\npytest==8.3.2\nruff==0.7.2",
			},
			expectedOutputs: []string{"Found"},
			expectedError:   false,
		},
		"Update when requirements.txt contain slack-bolt at top of file": {
			existingFiles: map[string]string{
				"requirements.txt": "slack-bolt==2.31.2\npytest==8.3.2\nruff==0.7.2",
			},
			expectedFiles: map[string]string{
				"requirements.txt": "slack-bolt==2.31.2\nslack-cli-hooks<1.0.0\npytest==8.3.2\nruff==0.7.2",
			},
			expectedOutputs: []string{"Updated"},
			expectedError:   false,
		},
		"Update when requirements.txt contain slack-bolt at middle of file": {
			existingFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nslack-bolt==2.31.2\nruff==0.7.2",
			},
			expectedFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nslack-bolt==2.31.2\nslack-cli-hooks<1.0.0\nruff==0.7.2",
			},
			expectedOutputs: []string{"Updated"},
			expectedError:   false,
		},
		"Update when requirements.txt contain slack-bolt at bottom of file": {
			existingFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nruff==0.7.2\nslack-bolt==2.31.2",
			},
			expectedFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nruff==0.7.2\nslack-bolt==2.31.2\nslack-cli-hooks<1.0.0",
			},
			expectedOutputs: []string{"Updated"},
			expectedError:   false,
		},
		"Update when requirements.txt does not contain slack-bolt": {
			existingFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nruff==0.7.2",
			},
			expectedFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nruff==0.7.2\nslack-cli-hooks<1.0.0",
			},
			expectedOutputs: []string{"Updated"},
			expectedError:   false,
		},
		"Update when requirements.txt with trailing whitespace does not contain slack-bolt": {
			existingFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nruff==0.7.2\n\n\n    ",
			},
			expectedFiles: map[string]string{
				"requirements.txt": "pytest==8.3.2\nruff==0.7.2\nslack-cli-hooks<1.0.0",
			},
			expectedOutputs: []string{"Updated"},
			expectedError:   false,
		},
		"Error when neither requirements.txt nor pyproject.toml exists": {
			existingFiles: map[string]string{
				"main.py": "# some python code",
			},
			expectedOutputs: []string{"Error: no Python dependency file found"},
			expectedError:   true,
		},
		"Skip when pyproject.toml contains slack-cli-hooks": {
			existingFiles: map[string]string{
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "slack-cli-hooks<1.0.0",
    "pytest==8.3.2",
]`,
			},
			expectedFiles: map[string]string{
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "slack-cli-hooks<1.0.0",
    "pytest==8.3.2",
]`,
			},
			expectedOutputs: []string{"Found pyproject.toml"},
			expectedError:   false,
		},
		"Update when pyproject.toml contains slack-bolt": {
			existingFiles: map[string]string{
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "slack-bolt>=1.0.0",
    "pytest==8.3.2",
]`,
			},
			expectedFiles: map[string]string{
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "slack-bolt>=1.0.0",
    "pytest==8.3.2",
    "slack-cli-hooks<1.0.0",
]`,
			},
			expectedOutputs: []string{"Updated pyproject.toml"},
			expectedError:   false,
		},
		"Update when pyproject.toml does not contain slack-bolt": {
			existingFiles: map[string]string{
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "pytest==8.3.2",
]`,
			},
			expectedFiles: map[string]string{
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "pytest==8.3.2",
    "slack-cli-hooks<1.0.0",
]`,
			},
			expectedOutputs: []string{"Updated pyproject.toml"},
			expectedError:   false,
		},
		"Update both requirements.txt and pyproject.toml when both exist": {
			existingFiles: map[string]string{
				"requirements.txt": "slack-bolt==2.31.2\npytest==8.3.2",
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "slack-bolt>=1.0.0",
]`,
			},
			expectedFiles: map[string]string{
				"requirements.txt": "slack-bolt==2.31.2\nslack-cli-hooks<1.0.0\npytest==8.3.2",
				"pyproject.toml": `[project]
name = "my-app"
dependencies = [
    "slack-bolt>=1.0.0",
    "slack-cli-hooks<1.0.0",
]`,
			},
			expectedOutputs: []string{"Updated requirements.txt"},
			expectedError:   false,
		},
		"Warning when pyproject.toml has no dependencies array": {
			existingFiles: map[string]string{
				"pyproject.toml": `[project]
name = "my-app"`,
			},
			expectedOutputs: []string{"Skipped updating pyproject.toml because dependencies missing"},
			expectedError:   false,
		},
		"Warning when pyproject.toml has no [project] section": {
			existingFiles: map[string]string{
				"pyproject.toml": `[tool.black]
line-length = 88`,
			},
			expectedOutputs: []string{"Skipped updating pyproject.toml because project section missing"},
			expectedError:   false,
		},
		"Warning when pyproject.toml is invalid TOML": {
			existingFiles: map[string]string{
				"pyproject.toml": `[project
name = "broken`,
			},
			expectedOutputs: []string{"Skipped updating pyproject.toml because invalid TOML"},
			expectedError:   false,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			// Setup
			ctx := slackcontext.MockContext(t.Context())
			fs := slackdeps.NewFsMock()
			os := slackdeps.NewOsMock()
			os.AddDefaultMocks()
			cfg := config.NewConfig(fs, os)
			ios := iostreams.NewIOStreamsMock(cfg, fs, os)
			ios.AddDefaultMocks()

			mockHookExecutor := &hooks.MockHookExecutor{}
			mockHookExecutor.On("Execute", mock.Anything, mock.Anything).Return("text output", nil)

			projectDirPath := "/path/to/project-name"

			// Create files
			for filePath, fileData := range tc.existingFiles {
				filePathAbs := filepath.Join(projectDirPath, filePath)
				// Create the directory
				if err := fs.MkdirAll(filepath.Dir(filePathAbs), 0755); err != nil {
					require.FailNow(t, fmt.Sprintf("Failed to create the directory %s in the memory-based file system", filePath))
				}
				// Create the file
				if err := afero.WriteFile(fs, filePathAbs, []byte(fileData), 0644); err != nil {
					require.FailNow(t, fmt.Sprintf("Failed to create the file %s in the memory-based file system", filePath))
				}
			}

			// Test
			p := New()
			outputs, err := p.InstallProjectDependencies(ctx, projectDirPath, mockHookExecutor, ios, fs, os)

			// Assertions
			for filePath, fileData := range tc.expectedFiles {
				filePathAbs := filepath.Join(projectDirPath, filePath)
				d, err := afero.ReadFile(fs, filePathAbs)
				require.NoError(t, err)
				require.Equal(t, fileData, string(d))
			}

			for _, expected := range tc.expectedOutputs {
				require.Contains(t, outputs, expected)
			}

			for _, notExpected := range tc.notExpectedOutputs {
				require.NotContains(t, outputs, notExpected)
			}

			if tc.expectedError {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}
		})
	}
}

func Test_Python_Name(t *testing.T) {
	p := New()
	require.Equal(t, "Python", p.Name())
}

func Test_Python_Version(t *testing.T) {
	tests := map[string]struct {
		expectedVersion string
	}{
		"Default version": {
			expectedVersion: "python",
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			p := New()
			require.Equal(t, tc.expectedVersion, p.Version())
		})
	}
}

func Test_Python_SetVersion(t *testing.T) {
	// Unsupported feature, but calling for test coverage
	p := New()
	p.SetVersion("unsupported")
	require.True(t, true)
}

func Test_Python_HooksJSONTemplate(t *testing.T) {
	tests := map[string]struct {
		hooksJSONTemplate []byte
		expectedErrorType error
	}{
		"HooksJSONTemplate() should be valid JSON": {
			hooksJSONTemplate: New().HooksJSONTemplate(),
			expectedErrorType: nil,
		},
		"Should fail on invalid JSON": {
			hooksJSONTemplate: []byte(`}{`),
			expectedErrorType: &json.SyntaxError{},
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			// Setup
			var anyJSON map[string]interface{}

			// Test
			err := json.Unmarshal(tc.hooksJSONTemplate, &anyJSON)

			// Assertions
			require.IsType(t, tc.expectedErrorType, err)
		})
	}
}

func Test_Python_PreparePackage(t *testing.T) {
	tests := map[string]struct {
		hookExecutorError           error
		expectedPreparePackageError error
	}{
		"Should return no error because unsupported": {
			hookExecutorError:           nil,
			expectedPreparePackageError: nil,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			ctx := slackcontext.MockContext(t.Context())

			// Setup SDKConfig
			mockSDKConfig := hooks.NewSDKConfigMock()
			mockSDKConfig.Hooks.BuildProject = hooks.HookScript{
				Name:    "BuildProject",
				Command: "./hook-script/build-project",
			}

			// Setup HookExecutor
			mockHookExecutor := &hooks.MockHookExecutor{}
			mockHookExecutor.On("Execute", mock.Anything, mock.Anything).Return("text output", tc.hookExecutorError)

			// Setup
			mockOpts := types.PreparePackageOpts{}
			mockOpts.AuthTokens = "auth-token-xxx"
			mockOpts.SrcDirPath = "src/dir/path"
			mockOpts.DstDirPath = "dst/dir/path"

			// Run tests
			p := New()
			err := p.PreparePackage(ctx, mockSDKConfig, mockHookExecutor, mockOpts)

			// Assertions
			require.Equal(t, tc.expectedPreparePackageError, err)
		})
	}
}

func Test_Python_IsRuntimeForProject(t *testing.T) {
	tests := map[string]struct {
		sdkConfigRuntime  string
		existingFilePaths []string
		expectedBool      bool
	}{
		"Not a Python project": {
			sdkConfigRuntime:  "", // Unset to check for file
			existingFilePaths: []string{},
			expectedBool:      false,
		},
		"SDKConfig Runtime is Python": {
			sdkConfigRuntime:  "python",
			existingFilePaths: []string{}, // Unset to check SDKConfig
			expectedBool:      true,
		},
		"requirements.txt file exists": {
			sdkConfigRuntime:  "", // Unset to check for file
			existingFilePaths: []string{"requirements.txt"},
			expectedBool:      true,
		},
		"pyproject.toml file exists": {
			sdkConfigRuntime:  "", // Unset to check for file
			existingFilePaths: []string{"pyproject.toml"},
			expectedBool:      true,
		},
		"both requirements.txt and pyproject.toml exist": {
			sdkConfigRuntime:  "", // Unset to check for file
			existingFilePaths: []string{"requirements.txt", "pyproject.toml"},
			expectedBool:      true,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			// Setup
			ctx := slackcontext.MockContext(t.Context())
			fs := slackdeps.NewFsMock()
			projectDirPath := "/path/to/project-name"

			// Create files
			for _, filePath := range tc.existingFilePaths {
				filePathAbs := filepath.Join(projectDirPath, filePath)
				// Create the directory
				if err := fs.MkdirAll(filepath.Dir(filePathAbs), 0755); err != nil {
					require.FailNow(t, fmt.Sprintf("Failed to create the directory %s in the memory-based file system", filePath))
				}
				// Create the file
				if err := afero.WriteFile(fs, filePathAbs, []byte("mock file data"), 0644); err != nil {
					require.FailNow(t, fmt.Sprintf("Failed to create the file %s in the memory-based file system", filePath))
				}
			}

			// Test
			b := IsRuntimeForProject(ctx, fs, projectDirPath, hooks.SDKCLIConfig{Runtime: tc.sdkConfigRuntime})

			// Assertions
			require.Equal(t, tc.expectedBool, b)
		})
	}
}

func Test_Python_getProjectDirRelPath(t *testing.T) {
	tests := map[string]struct {
		currentDirPath  string
		projectDirPath  string
		getwdPath       string
		getwdError      error
		expectedRelPath string
		expectedError   error
	}{
		"When currentDirPath missing and Getwd returns an error": {
			currentDirPath:  "",
			projectDirPath:  "path/to/my-project",
			getwdPath:       "",
			getwdError:      fmt.Errorf("Something went wrong"),
			expectedRelPath: "path/to/my-project",
			expectedError:   fmt.Errorf("Something went wrong"),
		},
		"When Rel returns an error": {
			currentDirPath:  "//host/some/remote/volume",
			projectDirPath:  "path/to/my-project",
			getwdPath:       "",  // Not called
			getwdError:      nil, // Not called
			expectedRelPath: "path/to/my-project",
			expectedError:   fmt.Errorf("Rel: can't make path/to/my-project relative to //host/some/remote/volume"),
		},
		"When current working directory outside the projectDirPath": {
			currentDirPath:  "path/to",
			projectDirPath:  "path/to/my-project",
			getwdPath:       "",  // Not called
			getwdError:      nil, // Not called
			expectedRelPath: "my-project",
			expectedError:   nil,
		},
		"When current working directory equals the projectDirPath": {
			currentDirPath:  "path/to/my-project",
			projectDirPath:  "path/to/my-project",
			getwdPath:       "",  // Not called
			getwdError:      nil, // Not called
			expectedRelPath: ".",
			expectedError:   nil,
		},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			// Create mocks
			osMock := slackdeps.NewOsMock()
			osMock.On("Getwd").Return(tc.getwdPath, tc.getwdError)
			osMock.AddDefaultMocks()

			// Run the test
			actualRelPath, actualErr := getProjectDirRelPath(osMock, tc.currentDirPath, tc.projectDirPath)

			// Assertions
			require.Equal(t, tc.expectedRelPath, actualRelPath)
			require.Equal(t, tc.expectedError, actualErr)
		})
	}
}