Comment simuler efficacement les interactions du système de fichiers pour les tests unitaires en Go ?

Test de l'interaction du système de fichiers dans Go avec des simulations

Se moquer du système de fichiers peut être utile lors des tests unitaires de fonctions qui interagissent avec le système de fichiers. Pour démontrer son utilisation, examinons une approche basée sur une interface, dans laquelle nous créons une interface fileSystem personnalisée qui encapsule les opérations du système de fichiers.

var fs fileSystem = osFS{}

type fileSystem interface {
    Open(name string) (file, error)
    Stat(name string) (os.FileInfo, error)
}

type file interface {
    io.Closer
    io.Reader
    io.ReaderAt
    io.Seeker
    Stat() (os.FileInfo, error)
}

// osFS implements fileSystem using the local disk.
type osFS struct{}

func (osFS) Open(name string) (file, error)        { return os.Open(name) }
func (osFS) Stat(name string) (os.FileInfo, error) { return os.Stat(name) }

Implémentation simulée :

Pour simuler le système de fichiers, nous pouvons créer une version simulée de l'interface fileSystem, appelée mockedFS. Cela nous permet de contrôler le comportement des opérations du système de fichiers pendant les tests.

Exemple de fonction :

Considérons une fonction getSize qui renvoie la taille du fichier à l'aide de filesystem.Stat méthode :

func getSize(name string) (int64, error) {
    stat, err := fs.Stat(name)
    if err != nil {
        return 0, err
    }
    return stat.Size(), nil
}

Configuration du Mock :

Avant de tester getSize, nous devons remplacer la variable globale fs par notre instance simulée :

func TestGetSize(t *testing.T) {
    // Save the original filesystem
    oldFs := fs

    // Replace with mocked filesystem
    mfs := &mockedFS{}
    fs = mfs

    // Restore original filesystem after test
    defer func() { fs = oldFs }()
}

Exécution du test :

Le code de test ci-dessous vérifie le comportement de la fonction getSize sous diverses erreurs et tailles de fichier conditions :

type mockedFS struct {
    reportErr  bool
    reportSize int64
}

func (mfs) Stat(name string) (os.FileInfo, error) {
    if mfs.reportErr {
        return nil, os.ErrNotExist
    }
    return &mockedFileInfo{size: mfs.reportSize}, nil
}

type mockedFileInfo struct {
    size int64
}

func (mfi mockedFileInfo) Size() int64 { return mfi.size }

// Test Error Case
func TestGetSize(t *testing.T) {
    ...
    mfs.reportErr = true
    if _, err := getSize("hello.go"); err == nil { ... }

// Test Non-Error Case
func TestGetSize(t *testing.T) {
    ...
    mfs.reportSize = 123
    if size, err := getSize("hello.go"); ... }

Cet exemple montre comment créer une interface de système de fichiers personnalisée, simuler son implémentation et l'utiliser pour tester une fonction qui interagit avec le système de fichiers, garantissant ainsi un environnement de test contrôlé dans Go.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!