Python Mock Open Fichier Exemple

Utilisez @patch ('mymodule.open', new_callable = mock_open) pour simuler les opérations de fichiers pour éviter de vraies fichiers de lecture et d'écriture; 2. Définissez le contenu du fichier Mock via le paramètre mock_open read_data, tel que read_data = 'debug = true'; 3. Vérifiez le résultat de retour et ouvrez les paramètres d'appel lors de la lecture de la fonction; 4. Obtenez la poignée via mock_file () et vérifiez l'appel de la méthode d'écriture lors de l'écriture de la fonction; 5. Utilisez latérale Side_Effect pour retourner plusieurs instances MOCK_OPEN lors de la moquerie de plusieurs lectures de différents fichiers; 6. La clé est que le chemin du patch doit pointer vers le module en utilisant Open, pas Butins.Open, sinon la simulation n'est pas valide.

L'utilisation de unittest.mock pour simuler les opérations de fichiers dans Python (comme open() ) est une astuce de test courante, surtout si vous souhaitez éviter de vraies fichiers de lecture et d'écriture. Voici un exemple pratique montrant comment utiliser mock pour simuler la fonction open() et les fonctions de test qui lisent ou écrivent des fichiers.

✅ Scénario: tester une fonction qui lit les fichiers de configuration

Supposons que vous ayez une fonction qui lit un fichier texte et renvoie le contenu:

 # mymodule.py
def read_config (nom de fichier):
    avec ouvert (nom de fichier, «r») comme f:
        return f.read (). strip ()

Nous ne voulons pas réellement lire un fichier pendant les tests, mais utilisez mock pour simuler open() .

✅ Utilisez patch pour simuler open()

 # test_mymodule.py
De Unittest.mock Import Mock_Open, patch
Importer unittest

# Supposons que la fonction ci-dessus se trouve dans le module Mymodule de Mymodule Import Read_config

classe TestReadConfig (unittest.testcase):

    @patch ('mymodule.open', new_callable = mock_open, read_data = 'debug = true')
    def test_read_config (self, mock_file):
        result = read_config ('config.txt')

        # Vérifiez le résultat sel-assertequal (résultat, 'debug = true')

        # Vérifiez que l'Open est appelé correctement mock_file.assert_called_once_with ('config.txt', 'r')

? Description des points clés

• @patch('mymodule.open', ...) :
  Notez que le chemin est 'mymodule.open' car open que vous souhaitez patcher est une fonction intégrée utilisée dans le module mymodule . Vous ne pouvez pas dire directement la fonction globale open intégrée , vous devez corriger open dans son module.

• mock_open(read_data='...') :
  Créer une valeur de retour open() simulée, read_data Spécifie le contenu renvoyé lorsque le fichier est lu.

  

• with open(...) as f: est automatiquement simulé, f.read() renvoie le contenu de read_data .

✅ Exemples d'imitation de l'écriture dans les fichiers

Supposons que vous ayez une fonction qui écrit des journaux:

 # mymodule.py
def write_log (nom de fichier, message):
    avec ouvert (nom de fichier, 'w') comme f:
        F.Write (message)

Opération d'écriture de test:

 @patch ('mymodule.open', new_callable = mock_open)
def test_write_log (self, mock_file):
    write_log ('log.txt', 'erreur s'est produite')

    # Vérifiez que vous ouvrez ouvert avec 'W' pour ouvrir mock_file.assert_called_once_with ('log.txt', 'w')

    # Vérifiez si l'écriture est appelée manche = mock_file ()
    handle.write.assert_called_once_with ('error s'est produit')

✅ Conseils: simulez plusieurs appels vers différents fichiers

 @patch ('mymodule.open', new_callable = mock_open)
def test_multiple_files (self, mock_file):
    mock_file.side_effected = [
        UNITTEST.MOCK.MOCK_OPEN (read_data = 'file1'). return_value,
        UNITTEST.MOCK.MOCK_OPEN (read_data = 'file2'). return_value,
    ]]

    data1 = read_config ('a.txt')
    data2 = read_config ('b.txt')

    self.assetertequal (data1, 'file1')
    self.asserTequal (data2, 'file2')

✅ Résumé: étapes clés

• Utilisez @patch('module.open', new_callable=mock_open) .
• Utilisez read_data pour définir le contenu de fichier simulé.
• Après les tests, vous pouvez vérifier si open() et write() sont appelés correctement.
• Notez que le chemin doit être correct (il s'agit d'utiliser des modules open , et non builtins.open ).

Fondamentalement, c'est tout. L'opération de fichier simulé n'est pas compliquée, mais elle est facile à échouer en raison de l'écriture de chemin de correctif incorrecte. N'oubliez pas de vérifier le nom du module et la méthode d'importation.

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!