Test to validate the nil functions

Author: suztomo

internal/librariangen/languagecontainer/generate/generate.go

@@ -42,16 +42,16 @@ type Context struct {
 // Validate ensures that the context is valid.
 func (c *Context) Validate() error {
 	if c.LibrarianDir == "" {
-		return errors.New("librariangen: librarian directory must be set")
+		return errors.New("languagecontainer: librarian directory must be set")
 	}
 	if c.InputDir == "" {
-		return errors.New("librariangen: input directory must be set")
+		return errors.New("languagecontainer: input directory must be set")
 	}
 	if c.OutputDir == "" {
-		return errors.New("librariangen: output directory must be set")
+		return errors.New("languagecontainer: output directory must be set")
 	}
 	if c.SourceDir == "" {
-		return errors.New("librariangen: source directory must be set")
+		return errors.New("languagecontainer: source directory must be set")
 	}
 	return nil
 }
@@ -69,16 +69,15 @@ type Config struct {
 // from the LibrarianDir in the given Context.
 func NewConfig(ctx *Context) (*Config, error) {
 	reqPath := filepath.Join(ctx.LibrarianDir, "generate-request.json")
-	slog.Debug("librariangen: reading generate request", "path", reqPath)
+	slog.Debug("languagecontainer: reading generate request", "path", reqPath)
 
 	generateReq, err := message.ParseLibrary(reqPath)
 	if err != nil {
 		return nil, err
 	}
-	slog.Debug("librariangen: successfully unmarshalled request", "library_id", generateReq.ID)
+	slog.Debug("languagecontainer: successfully unmarshalled request", "library_id", generateReq.ID)
 	return &Config{
 		Context: ctx,
 		Request: generateReq,
 	}, nil
 }
-

internal/librariangen/languagecontainer/languagecontainer.go

@@ -55,17 +55,25 @@ func Run(args []string, container *LanguageContainer) int {
 	flags := args[1:]
 	switch cmd {
 	case "generate":
+		if container.Generate == nil {
+			slog.Error("languagecontainer: generate command is not implemented")
+			return 1
+		}
 		return handleGenerate(flags, container)
 	case "configure":
-		slog.Warn("librariangen: configure command is not yet implemented")
+		slog.Warn("languagecontainer: configure command is missing")
 		return 1
 	case "release-init":
+		if container.ReleaseInit == nil {
+			slog.Error("languagecontainer: generate command is missing")
+			return 1
+		}
 		return handleReleaseInit(flags, container)
 	case "build":
-		slog.Warn("librariangen: build command is not yet implemented")
+		slog.Warn("languagecontainer: build command is not yet implemented")
 		return 1
 	default:
-		slog.Error(fmt.Sprintf("librariangen: unknown command: %s (with flags %v)", cmd, flags))
+		slog.Error(fmt.Sprintf("languagecontainer: unknown command: %s (with flags %v)", cmd, flags))
 		return 1
 	}
 }
@@ -90,7 +98,7 @@ func handleGenerate(flags []string, container *LanguageContainer) int {
 		slog.Error("generate failed", "error", err)
 		return 1
 	}
-	slog.Info("librariangen: generate command executed successfully")
+	slog.Info("languagecontainer: generate command executed successfully")
 	return 0
 }
 
@@ -134,6 +142,6 @@ func handleReleaseInit(flags []string, container *LanguageContainer) int {
 		slog.Error("failed to write response file", "path", responsePath, "error", err)
 		return 1
 	}
-	slog.Info("librariangen: release-init command executed successfully")
+	slog.Info("languagecontainer: release-init command executed successfully")
 	return 0
 }

internal/librariangen/languagecontainer/languagecontainer_test.go

@@ -233,3 +233,37 @@ func TestRun_GenerateReadsContextArgs(t *testing.T) {
 		t.Errorf("gotConfig.Context.SourceDir = %q, want %q", got, want)
 	}
 }
+
+func TestRun_unimplementedCommands(t *testing.T) {
+	tests := []struct {
+		name      string
+		args      []string
+		container *LanguageContainer
+	}{
+		{
+			name: "generate is nil",
+			args: []string{"generate"},
+			container: &LanguageContainer{
+				ReleaseInit: func(context.Context, *release.Config) (*message.ReleaseInitResponse, error) {
+					return nil, nil
+				},
+			},
+		},
+		{
+			name: "release-init is nil",
+			args: []string{"release-init"},
+			container: &LanguageContainer{
+				Generate: func(context.Context, *generate.Config) error {
+					return nil
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotCode := Run(tt.args, tt.container); gotCode != 1 {
+				t.Errorf("Run() = %v, want 1", gotCode)
+			}
+		})
+	}
+}