test(gemini-model): add unit tests to cover errors

- project and API key are mutually exclusive in the client initializer
- generate with empty model name
- maybe append user content when length is zero
- maybe append user content when there is no user role
- Name() method

Author: danielfs

model/gemini/constants.go

@@ -0,0 +1,6 @@
+package gemini
+
+const (
+	systemInstructionText  = "Handle the requests as specified in the System Instruction."
+	continueProcessingText = "Continue processing previous requests as instructed. Exit or provide a summary if no more outputs are needed."
+)

model/gemini/errors.go

@@ -0,0 +1,5 @@
+package gemini
+
+import "errors"
+
+var errEmptyModelName = errors.New("model name cannot be empty")

model/gemini/gemini.go

@@ -45,6 +45,10 @@ type geminiModel struct {
 //
 // An error is returned if the [genai.Client] fails to initialize.
 func NewModel(ctx context.Context, modelName string, cfg *genai.ClientConfig) (model.LLM, error) {
+	if modelName == "" {
+		return nil, errEmptyModelName
+	}
+
 	client, err := genai.NewClient(ctx, cfg)
 	if err != nil {
 		return nil, err
@@ -133,10 +137,19 @@ func (m *geminiModel) generateStream(ctx context.Context, req *model.LLMRequest)
 // maybeAppendUserContent appends a user content, so that model can continue to output.
 func (m *geminiModel) maybeAppendUserContent(req *model.LLMRequest) {
 	if len(req.Contents) == 0 {
-		req.Contents = append(req.Contents, genai.NewContentFromText("Handle the requests as specified in the System Instruction.", "user"))
+		req.Contents = append(req.Contents, genai.NewContentFromText(systemInstructionText, "user"))
+	}
+
+	// get the last non-nil content
+	var last genai.Content
+	for i := len(req.Contents) - 1; i >= 0; i-- {
+		if req.Contents[i] != nil {
+			last = *req.Contents[i]
+			break
+		}
 	}
 
-	if last := req.Contents[len(req.Contents)-1]; last != nil && last.Role != "user" {
-		req.Contents = append(req.Contents, genai.NewContentFromText("Continue processing previous requests as instructed. Exit or provide a summary if no more outputs are needed.", "user"))
+	if last.Role != "user" {
+		req.Contents = append(req.Contents, genai.NewContentFromText(continueProcessingText, "user"))
 	}
 }

model/gemini/gemini_test.go

@@ -15,6 +15,7 @@
 package gemini
 
 import (
+	"errors"
 	"fmt"
 	"iter"
 	"net/http"
@@ -187,6 +188,112 @@ func TestModel_TrackingHeaders(t *testing.T) {
 	})
 }
 
+func TestModel_Name(t *testing.T) {
+	model := &geminiModel{name: "gemini-2.5-flash"}
+	if got := model.Name(); got != "gemini-2.5-flash" {
+		t.Fatalf("Model.Name() = %v, want %v", got, "gemini-2.5-flash")
+	}
+}
+
+func TestModel_NewModelError(t *testing.T) {
+	_, err := NewModel(t.Context(), "gemini-2.5-flash", &genai.ClientConfig{
+		// project and API key are mutually exclusive in the client initializer
+		APIKey:  "api-key",
+		Project: "project-id",
+	})
+	if err == nil {
+		t.Fatal("NewModel() expected error due to project and API key are mutually exclusive, got nil")
+	}
+	if want := "mutually exclusive"; !strings.Contains(err.Error(), want) {
+		t.Fatalf("NewModel() error = %q, want to contain %q", err, want)
+	}
+}
+
+func TestModel_NewModelWithEmptyName(t *testing.T) {
+	_, err := NewModel(t.Context(), "", &genai.ClientConfig{
+		APIKey: "fakekey",
+	})
+	if err == nil {
+		t.Fatal("NewModel() expected error for empty model name, got nil")
+	}
+	if !errors.Is(err, errEmptyModelName) {
+		t.Fatalf("NewModel() error = %q, want to contain %q", err, errEmptyModelName.Error())
+	}
+}
+
+func TestModel_MaybeAppendUserContent(t *testing.T) {
+	tests := []struct {
+		name             string
+		initialContents  []*genai.Content
+		wantLen          int
+		wantLastRole     string
+		wantAppendedText string
+	}{
+		{
+			name:             "empty contents",
+			initialContents:  []*genai.Content{},
+			wantLen:          1,
+			wantLastRole:     genai.RoleUser,
+			wantAppendedText: systemInstructionText,
+		},
+		{
+			name:             "last role is not user",
+			initialContents:  []*genai.Content{{Role: genai.RoleModel}},
+			wantLen:          2,
+			wantLastRole:     genai.RoleUser,
+			wantAppendedText: continueProcessingText,
+		},
+		{
+			name:             "last role is user",
+			initialContents:  []*genai.Content{{Role: genai.RoleUser}},
+			wantLen:          1,
+			wantLastRole:     genai.RoleUser,
+			wantAppendedText: "",
+		},
+		{
+			name:             "last content from model, followed by nil",
+			initialContents:  []*genai.Content{{Role: genai.RoleModel}, nil},
+			wantLen:          3,
+			wantLastRole:     genai.RoleUser,
+			wantAppendedText: continueProcessingText,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			newModel := &geminiModel{name: "gemini-2.5-flash"}
+			contents := make([]*genai.Content, len(tt.initialContents))
+			copy(contents, tt.initialContents)
+			req := &model.LLMRequest{
+				Contents: contents,
+			}
+			newModel.maybeAppendUserContent(req)
+
+			if gotLen := len(req.Contents); gotLen != tt.wantLen {
+				t.Fatalf("Expected Contents length to be %d, got %d", tt.wantLen, gotLen)
+			}
+
+			if len(req.Contents) > 0 {
+				lastContent := req.Contents[len(req.Contents)-1]
+				if lastContent.Role != tt.wantLastRole {
+					t.Fatalf("Expected last content role to be %q, got %q", tt.wantLastRole, lastContent.Role)
+				}
+
+				if tt.wantAppendedText != "" {
+					if len(lastContent.Parts) == 0 {
+						t.Fatal("Expected appended content to have at least one part, but it has none")
+					}
+					textPart := lastContent.Parts[0].Text
+
+					if textPart != tt.wantAppendedText {
+						t.Errorf("Unexpected text in appended content. got %q, want %q", textPart, tt.wantAppendedText)
+					}
+				}
+			}
+		})
+	}
+}
+
 // newGeminiTestClientConfig returns the genai.ClientConfig configured for record and replay.
 func newGeminiTestClientConfig(t *testing.T, rrfile string) *genai.ClientConfig {
 	t.Helper()