Eliminate global state and co-locate integration tests

Author: pierres

README.md

@@ -119,7 +119,7 @@ To run the unit tests, run:
 just test
 ```
 
-This will run all unit tests alongside the source code in `internal/`.
+This will run all unit tests alongside the source code in `cmd/` and `internal/`.
 
 To generate a test coverage report, run:
 
@@ -172,4 +172,4 @@ The `pkgstats` project is structured as follows:
   - `system/`: Gathers system information like CPU architecture.
 - `main.go`: The main entry point of the application.
 - `justfile`: Contains the `just` commands for development and testing.
-- `tests/`: Contains the integration tests.
+- `tests/`: Contains the integration test Dockerfile.

cmd/architecture.go

@@ -8,70 +8,75 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var architectureCmd = &cobra.Command{
-	Use:     "architecture",
-	Aliases: []string{"arch"},
-	Short:   "Shows information about CPU and OS architecture",
-	Hidden:  true,
-	Args:    cobra.NoArgs,
-	RunE: func(cmd *cobra.Command, args []string) error {
-		s := system.NewSystem()
-
-		osArchitecture, err := s.GetArchitecture()
-		if err != nil {
-			return fmt.Errorf("could not get OS architecture: %w", err)
-		}
-
-		systemArchitecture, err := s.GetCpuArchitecture()
-		if err != nil {
-			return fmt.Errorf("could not get CPU architecture: %w", err)
-		}
-
-		fmt.Fprintf(cmd.OutOrStdout(), "You are using a %s CPU on a %s OS\n", systemArchitecture, osArchitecture)
-
-		return nil
-	},
+func newArchitectureCmd() *cobra.Command {
+	architectureCmd := &cobra.Command{
+		Use:     "architecture",
+		Aliases: []string{"arch"},
+		Short:   "Shows information about CPU and OS architecture",
+		Hidden:  true,
+		Args:    cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			s := system.NewSystem()
+
+			osArchitecture, err := s.GetArchitecture()
+			if err != nil {
+				return fmt.Errorf("could not get OS architecture: %w", err)
+			}
+
+			systemArchitecture, err := s.GetCpuArchitecture()
+			if err != nil {
+				return fmt.Errorf("could not get CPU architecture: %w", err)
+			}
+
+			fmt.Fprintf(cmd.OutOrStdout(), "You are using a %s CPU on a %s OS\n", systemArchitecture, osArchitecture)
+
+			return nil
+		},
+	}
+
+	architectureCmd.AddCommand(newOsArchitectureCmd())
+	architectureCmd.AddCommand(newSystemArchitectureCmd())
+
+	return architectureCmd
 }
 
-var osArchitectureCommand = &cobra.Command{
-	Use:   "os",
-	Short: "Shows OS architecture",
-	Args:  cobra.NoArgs,
-	RunE: func(cmd *cobra.Command, args []string) error {
-		s := system.NewSystem()
+func newOsArchitectureCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "os",
+		Short: "Shows OS architecture",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			s := system.NewSystem()
 
-		osArchitecture, err := s.GetArchitecture()
-		if err != nil {
-			return fmt.Errorf("could not get OS architecture: %w", err)
-		}
+			osArchitecture, err := s.GetArchitecture()
+			if err != nil {
+				return fmt.Errorf("could not get OS architecture: %w", err)
+			}
 
-		fmt.Fprintln(cmd.OutOrStdout(), osArchitecture)
+			fmt.Fprintln(cmd.OutOrStdout(), osArchitecture)
 
-		return nil
-	},
+			return nil
+		},
+	}
 }
 
-var systemArchitectureCommand = &cobra.Command{
-	Use:     "system",
-	Aliases: []string{"cpu"},
-	Short:   "Shows CPU architecture",
-	Args:    cobra.NoArgs,
-	RunE: func(cmd *cobra.Command, args []string) error {
-		s := system.NewSystem()
-
-		systemArchitecture, err := s.GetCpuArchitecture()
-		if err != nil {
-			return fmt.Errorf("could not get CPU architecture: %w", err)
-		}
-
-		fmt.Fprintln(cmd.OutOrStdout(), systemArchitecture)
-
-		return nil
-	},
-}
-
-func init() {
-	rootCmd.AddCommand(architectureCmd)
-	architectureCmd.AddCommand(osArchitectureCommand)
-	architectureCmd.AddCommand(systemArchitectureCommand)
+func newSystemArchitectureCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:     "system",
+		Aliases: []string{"cpu"},
+		Short:   "Shows CPU architecture",
+		Args:    cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			s := system.NewSystem()
+
+			systemArchitecture, err := s.GetCpuArchitecture()
+			if err != nil {
+				return fmt.Errorf("could not get CPU architecture: %w", err)
+			}
+
+			fmt.Fprintln(cmd.OutOrStdout(), systemArchitecture)
+
+			return nil
+		},
+	}
 }

cmd/architecture_test.go

@@ -0,0 +1,63 @@
+package cmd_test
+
+import (
+	"strings"
+	"testing"
+
+	"pkgstats-cli/internal/system"
+)
+
+func TestShowArchitecture(t *testing.T) {
+	output, err := pkgstats(t, []string{"architecture"})
+	if err != nil {
+		t.Fatalf("Failed to run command: %v", err)
+	}
+
+	s := system.NewSystem()
+	osArchitecture, err := s.GetArchitecture()
+	if err != nil {
+		t.Fatal(err)
+	}
+	cpuArchitecture, err := s.GetCpuArchitecture()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !strings.Contains(output, osArchitecture) || !strings.Contains(output, cpuArchitecture) {
+		t.Fatalf("Expected OS and CPU architecture %s and %s, but got %s", osArchitecture, cpuArchitecture, strings.TrimSpace(output))
+	}
+}
+
+func TestShowOsArchitecture(t *testing.T) {
+	output, err := pkgstats(t, []string{"architecture", "os"})
+	if err != nil {
+		t.Fatalf("Failed to run command: %v", err)
+	}
+
+	s := system.NewSystem()
+	osArchitecture, err := s.GetArchitecture()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if strings.TrimSpace(output) != osArchitecture {
+		t.Fatalf("Expected OS architecture %s, but got %s", osArchitecture, strings.TrimSpace(output))
+	}
+}
+
+func TestShowSystemArchitecture(t *testing.T) {
+	output, err := pkgstats(t, []string{"architecture", "system"})
+	if err != nil {
+		t.Fatalf("Failed to run command: %v", err)
+	}
+
+	s := system.NewSystem()
+	cpuArchitecture, err := s.GetCpuArchitecture()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if strings.TrimSpace(output) != cpuArchitecture {
+		t.Fatalf("Expected CPU architecture %s, but got %s", cpuArchitecture, strings.TrimSpace(output))
+	}
+}

cmd/root.go

@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"fmt"
 	"os"
 
 	"pkgstats-cli/internal/build"
@@ -15,46 +14,42 @@ const (
 	pkgstatsConfParam = "pkgstats-conf"
 )
 
-var (
-	baseURL      = "https://pkgstats.archlinux.de"
-	pacmanConf   = "/etc/pacman.conf"
-	pkgstatsConf = ""
-	rootCmd      = &cobra.Command{
+func Execute() {
+	if err := NewRootCmd().Execute(); err != nil {
+		os.Exit(1)
+	}
+}
+
+func NewRootCmd() *cobra.Command {
+	var (
+		baseURL      = "https://pkgstats.archlinux.de"
+		pacmanConf   = "/etc/pacman.conf"
+		pkgstatsConf = ""
+	)
+
+	rootCmd := &cobra.Command{
 		Use:          "pkgstats",
 		Short:        "pkgstats client",
 		Version:      build.Version,
 		SilenceUsage: true,
 	}
-)
-
-func Execute() {
-	if err := rootCmd.Execute(); err != nil {
-		os.Exit(1)
-	}
-}
 
-func init() {
 	rootCmd.PersistentFlags().StringVar(&baseURL, baseUrlParam, baseURL, "base url of the pkgstats server")
-	if err := rootCmd.PersistentFlags().MarkHidden(baseUrlParam); err != nil {
-		fmt.Fprintln(rootCmd.ErrOrStderr(), err)
-		os.Exit(1)
-	}
+	_ = rootCmd.PersistentFlags().MarkHidden(baseUrlParam)
 
 	rootCmd.PersistentFlags().StringVar(&pacmanConf, pacmanConfParam, pacmanConf, "path to pacman.conf")
-	if err := rootCmd.PersistentFlags().MarkHidden(pacmanConfParam); err != nil {
-		fmt.Fprintln(rootCmd.ErrOrStderr(), err)
-		os.Exit(1)
-	}
+	_ = rootCmd.PersistentFlags().MarkHidden(pacmanConfParam)
 
 	rootCmd.PersistentFlags().StringVarP(&pkgstatsConf, pkgstatsConfParam, "c", pkgstatsConf, "path to pkgstats config file")
-	if err := rootCmd.PersistentFlags().MarkHidden(pkgstatsConfParam); err != nil {
-		fmt.Fprintln(rootCmd.ErrOrStderr(), err)
-		os.Exit(1)
-	}
+	_ = rootCmd.PersistentFlags().MarkHidden(pkgstatsConfParam)
 
 	rootCmd.CompletionOptions.HiddenDefaultCmd = true
-}
 
-func GetRootCmd() *cobra.Command {
+	rootCmd.AddCommand(newSubmitCmd(&baseURL, &pacmanConf, &pkgstatsConf))
+	rootCmd.AddCommand(newSearchCmd(&baseURL))
+	rootCmd.AddCommand(newShowCmd(&baseURL))
+	rootCmd.AddCommand(newArchitectureCmd())
+	rootCmd.AddCommand(newVersionCmd())
+
 	return rootCmd
 }

cmd/root_test.go

@@ -0,0 +1,16 @@
+package cmd_test
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestShowHelp(t *testing.T) {
+	output, err := pkgstats(t, []string{"help"})
+	if err != nil {
+		t.Fatalf("Failed to run command: %v", err)
+	}
+	if !strings.Contains(output, "Usage:") {
+		t.Errorf("Expected help output to contain 'Usage:', got %s", output)
+	}
+}

cmd/search.go

@@ -13,36 +13,37 @@ const (
 	maxLimit = 10000
 )
 
-var limit = 10
-
-var searchCmd = &cobra.Command{
-	Use:   "search",
-	Short: "Search packages and list their popularity",
-	Args:  cobra.ExactArgs(1),
-	RunE: func(cmd *cobra.Command, args []string) error {
-		if limit < minLimit || limit > maxLimit {
-			return fmt.Errorf("valid limit needs to be between %d and %d", minLimit, maxLimit)
-		}
-		if err := request.ValidatePackageName(args[0]); err != nil {
-			return err
-		}
-
-		client := request.NewClient(baseURL)
-
-		ppl, err := client.SearchPackages(args[0], limit)
-		if err != nil {
-			return err
-		}
-
-		request.PrintPackagePopularities(cmd.OutOrStdout(), ppl)
-		fmt.Fprintln(cmd.OutOrStdout())
-		request.PrintSearchURL(cmd.OutOrStdout(), baseURL, args[0])
-
-		return nil
-	},
-}
+func newSearchCmd(baseURL *string) *cobra.Command {
+	limit := 10
+
+	searchCmd := &cobra.Command{
+		Use:   "search",
+		Short: "Search packages and list their popularity",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if limit < minLimit || limit > maxLimit {
+				return fmt.Errorf("valid limit needs to be between %d and %d", minLimit, maxLimit)
+			}
+			if err := request.ValidatePackageName(args[0]); err != nil {
+				return err
+			}
+
+			client := request.NewClient(*baseURL)
+
+			ppl, err := client.SearchPackages(args[0], limit)
+			if err != nil {
+				return err
+			}
+
+			request.PrintPackagePopularities(cmd.OutOrStdout(), ppl)
+			fmt.Fprintln(cmd.OutOrStdout())
+			request.PrintSearchURL(cmd.OutOrStdout(), *baseURL, args[0])
+
+			return nil
+		},
+	}
 
-func init() {
-	rootCmd.AddCommand(searchCmd)
 	searchCmd.Flags().IntVarP(&limit, "limit", "l", limit, fmt.Sprintf("Limit the results from %d to %d entries", minLimit, maxLimit))
+
+	return searchCmd
 }