Refactoring-Tipps für das Testen von Go-Funktionseinheiten

import "testing"

func AssertEqual(t *testing.T, expected, actual interface{}) {
    if expected != actual {
        t.Errorf("Expected %v, got %v", expected, actual)
    }
}

import (
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestMax(t *testing.T) {
    tests := []struct {
        name    string
        input   []int
        expected int
    }{
        {"Empty slice", []int{}, 0},
        {"Single element", []int{1}, 1},
        {"Multiple elements", []int{1, 2, 3}, 3},
    }

    for _, tt := range tests {
        actual := Max(tt.input)
        assert.Equal(t, tt.expected, actual)
    }
}

package main

import (
    "database/sql"
    "fmt"
    "time"

    "github.com/stretchr/testify/mock"
)

// MockDatabase is a mock database for testing purposes.
type MockDatabase struct {
    mock.Mock
}

// Query implements the Query method of a mock database.
func (m *MockDatabase) Query(query string, args ...interface{}) (*sql.Rows, error) {
    ret := m.Called(query, args)
    return ret.Get(0).(*sql.Rows), ret.Error(1)
}

// GetUserByUsernameAndPassword implements the GetUserByUsernameAndPassword method of a mock database.
func (m *MockDatabase) GetUserByUsernameAndPassword(username, password string) (*User, error) {
    ret := m.Called(username, password)
    return ret.Get(0).(*User), ret.Error(1)
}

// User represents a user in the database.
type User struct {
    Username string
    Password string
    LastLogin time.Time
}

// main is the entry point for the program.
func main() {
    mockDB := &MockDatabase{}
    mockDB.On("GetUserByUsernameAndPassword", "john", "password").Return(&User{
        Username: "john",
        Password: "password",
        LastLogin: time.Now(),
    }, nil)

    user, err := GetUser(mockDB, "john", "password")
    if err != nil {
        fmt.Println("Error getting user:", err)
    } else {
        fmt.Println("Welcome back, ", user.Username)
    }
}

import "testing"

func TestMaxElement(t *testing.T) {
    tests := []struct {
        name    string
        input   []int
        expected int
    }{
        {"Empty slice", []int{}, 0},
        {"Single element", []int{1}, 1},
        {"Multiple elements", []int{1, 2, 3}, 3},
    }

    for _, tt := range tests {
        actual := MaxElement(tt.input)
        assert.Equal(t, tt.expected, actual)
    }
}