request_validation_test.go

Overview

This file contains unit tests for validating various request types within the artifact package. The primary focus is on testing the correctness of the Validate methods implemented by request structs such as SaveRequest, LoadRequest, DeleteRequest, ListRequest, and VersionsRequest. Each request type implements the Validator interface, which requires a Validate() error method to ensure the request's fields meet predefined constraints before processing.

The tests verify that required fields are present and correctly handled, and that appropriate error messages are returned when validations fail. The file also includes tests for the helper function validateRequiredStrings, which checks for missing required string fields and returns their names.

Interface and Structs

Validator Interface

type Validator interface {
	Validate() error
}

• Purpose: Defines a contract for request types to implement self-validation logic.

• Usage: Each request struct implements Validate() to check required fields and return an error if validation fails.

ValidatorTestCase Struct

type ValidatorTestCase struct {
	name       string
	req        Validator
	wantErr    bool
	wantErrMsg string
}

• Fields:

  • name: Descriptive name of the test case.

  • req: The request instance implementing Validator to be validated.

  • wantErr: Boolean indicating if an error is expected.

  • wantErrMsg: Expected error message string if validation fails.

• Usage: Defines test case inputs and expected outcomes for validator tests.

Test Functions

Each test function targets one request type's Validate method, providing multiple scenarios with expected results.

TestSaveRequest_Validate

• Tests: Validation of SaveRequest

• Key Fields Validated: AppName, UserID, SessionID, FileName, Part

• Error Conditions: Missing required fields or invalid Part (e.g., nil or incomplete inline data)

• Example Usage:

req := &SaveRequest{
	AppName:   "MyApp",
	UserID:    "user-123",
	SessionID: "sess-abc",
	FileName:  "file.txt",
	Part:      genai.NewPartFromBytes([]byte("data"), "text/plain"),
}
err := req.Validate()

• Returns: nil if valid, error with message specifying missing fields otherwise.

TestLoadRequest_Validate

• Tests: Validation of LoadRequest

• Key Fields Validated: AppName, UserID, SessionID, FileName

• Error Conditions: Missing any required field triggers an error.

TestDeleteRequest_Validate

• Tests: Validation of DeleteRequest

• Key Fields Validated: Same as LoadRequest

• Error Conditions: Missing fields cause validation failure.

TestListRequest_Validate

• Tests: Validation of ListRequest

• Key Fields Validated: AppName, UserID, SessionID

• Error Conditions: Missing required fields trigger errors.

TestVersionsRequest_Validate

• Tests: Validation of VersionsRequest

• Key Fields Validated: AppName, UserID, SessionID, FileName

• Error Conditions: Missing fields cause validation failure.

TestValidateRequiredStrings

• Tests: Helper function validateRequiredStrings which checks slices of requiredField structs for missing values.

• Input: Slice of requiredField with Name and Value.

• Output: Slice of field names that are missing (empty string).

• Example:

fields := []requiredField{
	{Name: "FieldA", Value: "valueA"},
	{Name: "FieldB", Value: ""},
}
missing := validateRequiredStrings(fields)
// missing == []string{"FieldB"}

Helper Function

executeValidatorTestCases

func executeValidatorTestCases(t *testing.T, requestTypeName string, testCases []ValidatorTestCase)

• Purpose: Executes a suite of validator test cases for a given request type.

• Parameters:

  • t: Testing context.

  • requestTypeName: String identifier for the request type (used in test names).

  • testCases: Slice of ValidatorTestCase defining inputs and expected results.

• Logic:

  • Iterates over test cases.

  • Calls Validate() on each request.

  • Checks if error presence and error message match expectations.

  • Reports failures using t.Errorf.

• Usage: Centralizes repetitive test execution logic for all request validations.

Implementation Details and Algorithms

• The validation tests rely on the Validate() methods implemented by request structs, which are expected to return detailed error messages listing missing fields.

• The error messages use a consistent format specifying missing fields in a comma-separated list, enabling straightforward string comparison in tests.

• The helper function validateRequiredStrings scans required fields for empty values and returns their names, supporting validation logic inside request Validate() methods.

• The tests cover positive cases (valid requests) and multiple negative cases including single and multiple missing fields.

• The approach ensures that requests are thoroughly validated before further processing in the system.

Interaction with Other System Components

• The requests tested here (SaveRequest, LoadRequest, DeleteRequest, ListRequest, VersionsRequest) are part of the artifact management system described in the artifact package.

• These requests likely correspond to API inputs or internal service calls in the artifact service workflows, which manage storing, retrieving, deleting, listing, and versioning artifacts.

• The genai package is used to create Part objects representing data parts to be saved or managed, indicating integration with artifact content handling.

• The validation performed here ensures data integrity and correctness before requests are processed by the artifact service implementations, aligning with the broader Artifact Management topic.

Visual Diagram: Test Structure and Workflow

flowchart TD
ValidatorTestCase -->|holds| Validator
Validator -->|implemented by| SaveRequest
Validator -->|implemented by| LoadRequest
Validator -->|implemented by| DeleteRequest
Validator -->|implemented by| ListRequest
Validator -->|implemented by| VersionsRequest
subgraph TestSuites
TS1[TestSaveRequest_Validate]
TS2[TestLoadRequest_Validate]
TS3[TestDeleteRequest_Validate]
TS4[TestListRequest_Validate]
TS5[TestVersionsRequest_Validate]
end
TS1 --> ValidatorTestCase
TS2 --> ValidatorTestCase
TS3 --> ValidatorTestCase
TS4 --> ValidatorTestCase
TS5 --> ValidatorTestCase
ValidatorTestCase --> executeValidatorTestCases
executeValidatorTestCases -->|calls Validate()| Validator
executeValidatorTestCases -->|checks error| t.Errorf

This diagram summarizes the relationship between the test cases, the Validator interface implementations, and the centralized test executor function.

Note: For detailed validation rules and error message formats, refer to the request type definitions and their Validate() methods in the main artifact package source code. This file focuses exclusively on testing those validations. For related concepts on artifact storage and management, see the Artifact Management topic.