refactor and introduce tests for npm & pypi (#79)

* refactor and introduce tests for npm & pypi

* refactor and introduce tests for npm & pypi

* add skip intermediate flags test case

* fix tests

---------

Co-authored-by: Abhisek Datta <abhisek.datta@gmail.com>

packagemanager/npm_test.go

@@ -148,3 +148,213 @@ func TestNpmParseCommand(t *testing.T) {
 		})
 	}
 }
+
+func TestYarnParseCommand(t *testing.T) {
+	cases := []struct {
+		name    string
+		command string
+		assert  func(t *testing.T, parsedCommand *ParsedCommand, err error)
+	}{
+		{
+			name:    "install a single package",
+			command: "yarn add @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+				assert.Empty(t, parsedCommand.InstallTargets[0].PackageVersion.Version)
+			},
+		},
+		{
+			name:    "manifest installation with install command",
+			command: "yarn install",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
+				assert.Equal(t, true, parsedCommand.IsManifestInstall)
+			},
+		},
+		{
+			name:    "bare yarn command (manifest install)",
+			command: "yarn",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
+				assert.Equal(t, true, parsedCommand.IsManifestInstall)
+			},
+		},
+		{
+			name:    "yarn install with package name (invalid syntax)",
+			command: "yarn install express",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.NotNil(t, parsedCommand)
+				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
+				assert.Equal(t, false, parsedCommand.IsManifestInstall)
+			},
+		},
+		{
+			name:    "second package has a version",
+			command: "yarn add express @types/node@1.2.3",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 2, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "express", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+				assert.Empty(t, parsedCommand.InstallTargets[0].PackageVersion.Version)
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[1].PackageVersion.Package.Name)
+				assert.Equal(t, "1.2.3", parsedCommand.InstallTargets[1].PackageVersion.Version)
+			},
+		},
+		{
+			name:    "skip intermediate flags",
+			command: "yarn --x -y add @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			yarn, err := NewNpmPackageManager(DefaultYarnPackageManagerConfig())
+			assert.NoError(t, err)
+
+			parsedCommand, err := yarn.ParseCommand(strings.Split(tc.command, " "))
+			tc.assert(t, parsedCommand, err)
+		})
+	}
+}
+
+func TestPnpmParseCommand(t *testing.T) {
+	cases := []struct {
+		name    string
+		command string
+		assert  func(t *testing.T, parsedCommand *ParsedCommand, err error)
+	}{
+		{
+			name:    "install a single package",
+			command: "pnpm add @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+				assert.Empty(t, parsedCommand.InstallTargets[0].PackageVersion.Version)
+			},
+		},
+		{
+			name:    "install a development package with short flag",
+			command: "pnpm i -D @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+			},
+		},
+		{
+			name:    "manifest installation",
+			command: "pnpm install",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, true, parsedCommand.IsManifestInstall)
+				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
+			},
+		},
+		{
+			name:    "multiple package installations",
+			command: "pnpm add @types/node @types/react",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 2, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+				assert.Equal(t, "@types/react", parsedCommand.InstallTargets[1].PackageVersion.Package.Name)
+			},
+		},
+		{
+			name:    "skip intermediate flags",
+			command: "pnpm --x -y add @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			pnpm, err := NewNpmPackageManager(DefaultPnpmPackageManagerConfig())
+			assert.NoError(t, err)
+
+			parsedCommand, err := pnpm.ParseCommand(strings.Split(tc.command, " "))
+			tc.assert(t, parsedCommand, err)
+		})
+	}
+}
+
+func TestBunParseCommand(t *testing.T) {
+	cases := []struct {
+		name    string
+		command string
+		assert  func(t *testing.T, parsedCommand *ParsedCommand, err error)
+	}{
+		{
+			name:    "install a single package",
+			command: "bun add @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+				assert.Empty(t, parsedCommand.InstallTargets[0].PackageVersion.Version)
+			},
+		},
+		{
+			name:    "install a development package with short flag",
+			command: "bun add -d @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+			},
+		},
+		{
+			name:    "manifest installation",
+			command: "bun install",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, true, parsedCommand.IsManifestInstall)
+				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
+			},
+		},
+		{
+			name:    "multiple package installations",
+			command: "bun add @types/node @types/react",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 2, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+				assert.Equal(t, "@types/react", parsedCommand.InstallTargets[1].PackageVersion.Package.Name)
+			},
+		},
+		{
+			name:    "skip intermediate flags",
+			command: "bun --x -y add @types/node",
+			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
+				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			bun, err := NewNpmPackageManager(DefaultBunPackageManagerConfig())
+			assert.NoError(t, err)
+
+			parsedCommand, err := bun.ParseCommand(strings.Split(tc.command, " "))
+			tc.assert(t, parsedCommand, err)
+		})
+	}
+}

packagemanager/pypi.go

@@ -103,7 +103,7 @@ func NewPipCommandParser(config PypiPackageManagerConfig) pypiCommandParser {
 
 func (p *pipCommandParser) ParseCommand(args []string) (*ParsedCommand, error) {
 	// Remove 'pip' if it's the first argument
-	if len(args) > 0 && args[0] == "pip" {
+	if len(args) > 0 && (args[0] == "pip" || args[0] == "pip3") {
 		args = args[1:]
 	}
 
@@ -130,7 +130,7 @@ func (p *pipCommandParser) ParseCommand(args []string) (*ParsedCommand, error) {
 	// Extract arguments after the install command
 	installArgs := args[installCmdIndex+1:]
 
-	flagSet := pflag.NewFlagSet("pip", pflag.ContinueOnError)
+	flagSet := pflag.NewFlagSet(p.config.CommandName, pflag.ContinueOnError)
 	flagSet.SetOutput(io.Discard)
 	flagSet.ParseErrorsWhitelist.UnknownFlags = true
 

packagemanager/pypi_test.go

@@ -205,6 +205,99 @@ func TestPipParseCommand(t *testing.T) {
 	}
 }
 
+func TestPip3ParseCommand(t *testing.T) {
+	pm, err := NewPypiPackageManager(DefaultPip3PackageManagerConfig())
+	assert.NoError(t, err)
+
+	cases := []struct {
+		name             string
+		args             []string
+		expectedManifest bool
+		expectedFiles    []string
+		expectedTargets  int
+	}{
+		{
+			name:             "pip3 install with -r flag",
+			args:             []string{"install", "-r", "requirements.txt"},
+			expectedManifest: true,
+			expectedFiles:    []string{"requirements.txt"},
+			expectedTargets:  0,
+		},
+		{
+			name:             "pip3 install with -r flag with different filename",
+			args:             []string{"install", "-r", "requirements-dev.txt"},
+			expectedManifest: true,
+			expectedFiles:    []string{"requirements-dev.txt"},
+			expectedTargets:  0,
+		},
+		{
+			name:             "pip3 install with --requirement flag",
+			args:             []string{"install", "--requirement", "requirements.txt"},
+			expectedManifest: true,
+			expectedFiles:    []string{"requirements.txt"},
+			expectedTargets:  0,
+		},
+		{
+			name:             "pip3 install with combined -r flag",
+			args:             []string{"install", "-rrequirements.txt"},
+			expectedManifest: true,
+			expectedFiles:    []string{"requirements.txt"},
+			expectedTargets:  0,
+		},
+		{
+			name:             "pip3 install without args",
+			args:             []string{"install"},
+			expectedManifest: false,
+			expectedFiles:    nil,
+			expectedTargets:  0,
+		},
+		{
+			name:             "pip3 install with explicit package",
+			args:             []string{"install", "django"},
+			expectedManifest: false,
+			expectedFiles:    nil,
+			expectedTargets:  1,
+		},
+		{
+			name:             "pip3 install with mixed args",
+			args:             []string{"install", "django", "-r", "requirements.txt"},
+			expectedManifest: true,
+			expectedFiles:    []string{"requirements.txt"},
+			expectedTargets:  1,
+		},
+		{
+			name:             "pip3 install with multiple -r flags",
+			args:             []string{"install", "-r", "requirements.txt", "-r", "dev-requirements.txt"},
+			expectedManifest: true,
+			expectedFiles:    []string{"requirements.txt", "dev-requirements.txt"},
+			expectedTargets:  0,
+		},
+		{
+			name:             "non-install command",
+			args:             []string{"list"},
+			expectedManifest: false,
+			expectedFiles:    nil,
+			expectedTargets:  0,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			parsed, err := pm.ParseCommand(tc.args)
+			assert.NoError(t, err)
+
+			assert.Equal(t, tc.expectedManifest, parsed.IsManifestInstall, "IsManifestInstall mismatch")
+			assert.Equal(t, tc.expectedFiles, parsed.ManifestFiles, "ManifestFiles mismatch")
+			assert.Equal(t, tc.expectedTargets, len(parsed.InstallTargets), "InstallTargets count mismatch")
+
+			assert.Equal(t, tc.expectedManifest, parsed.HasManifestInstall(), "HasManifestInstall mismatch")
+
+			expectedShouldExtract := tc.expectedManifest && tc.expectedTargets == 0
+			assert.Equal(t, expectedShouldExtract, parsed.ShouldExtractFromManifest(), "ShouldExtractFromManifest mismatch")
+		})
+	}
+}
+
 func TestPipConvertCompatibleRelease(t *testing.T) {
 	cases := []struct {
 		name     string

packagemanager/yarn_test.go

@@ -1,161 +0,0 @@
-package packagemanager
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestYarnParseCommand(t *testing.T) {
-	cases := []struct {
-		name    string
-		command string
-		assert  func(t *testing.T, parsedCommand *ParsedCommand, err error)
-	}{
-		{
-			name:    "install a single package",
-			command: "yarn add @types/node",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-				assert.Empty(t, parsedCommand.InstallTargets[0].PackageVersion.Version)
-			},
-		},
-		{
-			name:    "install a single package with specific version",
-			command: "yarn add @types/node@1.2.3",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-				assert.Equal(t, "1.2.3", parsedCommand.InstallTargets[0].PackageVersion.Version)
-			},
-		},
-		{
-			name:    "install a development package",
-			command: "yarn add --dev @types/node",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-			},
-		},
-		{
-			name:    "install a development package with short flag",
-			command: "yarn add -D @types/node",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-			},
-		},
-		{
-			name:    "manifest installation with install command",
-			command: "yarn install",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
-				assert.Equal(t, true, parsedCommand.IsManifestInstall)
-			},
-		},
-		{
-			name:    "bare yarn command (manifest install)",
-			command: "yarn",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
-				assert.Equal(t, true, parsedCommand.IsManifestInstall)
-			},
-		},
-		{
-			name:    "yarn install with package name (invalid syntax)",
-			command: "yarn install express",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.NotNil(t, parsedCommand)
-				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
-				assert.Equal(t, false, parsedCommand.IsManifestInstall)
-			},
-		},
-		{
-			name:    "multiple package installations",
-			command: "yarn add @types/node @types/react",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 2, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-				assert.Equal(t, "@types/react", parsedCommand.InstallTargets[1].PackageVersion.Package.Name)
-			},
-		},
-		{
-			name:    "not an installation command",
-			command: "yarn remove @types/node",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.NotNil(t, parsedCommand)
-				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
-			},
-		},
-		{
-			name:    "skip intermediate flags",
-			command: "yarn --x -y add @types/node",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-			},
-		},
-		{
-			name:    "multiple development packages",
-			command: "yarn add -D @types/node -D @types/react",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 2, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-				assert.Equal(t, "@types/react", parsedCommand.InstallTargets[1].PackageVersion.Package.Name)
-			},
-		},
-		{
-			name:    "second package has a version",
-			command: "yarn add express @types/node@1.2.3",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 2, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "express", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-				assert.Empty(t, parsedCommand.InstallTargets[0].PackageVersion.Version)
-				assert.Equal(t, "@types/node", parsedCommand.InstallTargets[1].PackageVersion.Package.Name)
-				assert.Equal(t, "1.2.3", parsedCommand.InstallTargets[1].PackageVersion.Version)
-			},
-		},
-		{
-			name:    "yarn add with dev flag but no packages",
-			command: "yarn add --dev",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 0, len(parsedCommand.InstallTargets))
-				assert.Equal(t, false, parsedCommand.IsManifestInstall)
-			},
-		},
-		{
-			name:    "yarn with global flag",
-			command: "yarn global add typescript",
-			assert: func(t *testing.T, parsedCommand *ParsedCommand, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, 1, len(parsedCommand.InstallTargets))
-				assert.Equal(t, "typescript", parsedCommand.InstallTargets[0].PackageVersion.Package.Name)
-			},
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			yarn, err := NewNpmPackageManager(DefaultYarnPackageManagerConfig())
-			assert.NoError(t, err)
-
-			parsedCommand, err := yarn.ParseCommand(strings.Split(tc.command, " "))
-			tc.assert(t, parsedCommand, err)
-		})
-	}
-}