unittest.mock — ξεκινώντας

Added in version 3.3.

Χρήση της Προσομοίωσης (Mock)

Προσομοίωση Μεθόδων με Επιδιόρθωση (Patching)

Κοινές χρήσεις για αντικείμενα Mock περιλαμβάνουν:

• Επιδιόρθωση (Patching) μεθόδων

• Καταγραφή κλήσεων μεθόδων σε αντικείμενα

Ίσως θέλετε να αντικαταστήσετε μια μέθοδο σε ένα αντικείμενο για να ελέγξετε ότι καλείται με τα σωστά ορίσματα από ένα άλλο μέρος του συστήματος:

>>> real = SomeClass()
>>> real.method = MagicMock(name='method')
>>> real.method(3, 4, 5, key='value')
<MagicMock name='method()' id='...'>

Μόλις χρησιμοποιηθεί η προσομοίωσή μας (real.method σε αυτό το παράδειγμα) θα έχει μεθόδους και χαρακτηριστικά που σας επιτρέπουν να κάνετε δηλώσεις σχετικά με το πώς έχει χρησιμοποιηθεί.

Σημείωση

Στα περισσότερα από αυτά τα παραδείγματα οι κλάσεις Mock και MagicMock είναι εναλλάξιμες. Καθώς η MagicMock είναι η πιο ικανή κλάση, αποτελεί μια λογική επιλογή για χρήση από προεπιλογή.

Μόλις κληθεί η προσομοίωση, το χαρακτηριστικό called ορίζεται σε True. Πιο σημαντικό είναι ότι μπορούμε να χρησιμοποιήσουμε τη μέθοδο assert_called_with() ή assert_called_once_with() για να ελέγξουμε ότι κλήθηκε με τα σωστά ορίσματα.

Αυτό το παράδειγμα ελέγχει ότι η κλήση της ProductionClass().method έχει ως αποτέλεσμα μια κλήση στη μέθοδο something:

>>> class ProductionClass:
...     def method(self):
...         self.something(1, 2, 3)
...     def something(self, a, b, c):
...         pass
...
>>> real = ProductionClass()
>>> real.something = MagicMock()
>>> real.method()
>>> real.something.assert_called_once_with(1, 2, 3)

Προσομοίωση για Κλήσεις Μεθόδων σε ένα Αντικείμενο

Στο τελευταίο παράδειγμα επιδιορθώσαμε μια μέθοδο απευθείας σε ένα αντικείμενο για να ελέγξουμε ότι κλήθηκε σωστά. Μια άλλη κοινή χρήση είναι να περάσουμε ένα αντικείμενο σε μια μέθοδο (ή σε κάποιο μέρος του συστήματος υπό δοκιμή) και στη συνέχεια να ελέγξουμε ότι χρησιμοποιείται με τον σωστό τρόπο.

Η απλή ProductionClass παρακάτω έχει μια μέθοδο closer. Εάν κληθεί με ένα αντικείμενο, τότε καλεί τη μέθοδο close σε αυτό.

>>> class ProductionClass:
...     def closer(self, something):
...         something.close()
...

Έτσι, για να το δοκιμάσουμε, πρέπει να περάσουμε ένα αντικείμενο με μια μέθοδο close και να ελέγξουμε ότι κλήθηκε σωστά.

>>> real = ProductionClass()
>>> mock = Mock()
>>> real.closer(mock)
>>> mock.close.assert_called_with()

Δεν χρειάζεται να κάνουμε καμία εργασία για να παρέχουμε τη μέθοδο “close” στην προσομοίωσή μας. Η πρόσβαση στο close τη δημιουργεί. Έτσι, αν το “close” δεν έχει ήδη κληθεί, τότε η πρόσβαση σε αυτό στη δοκιμή θα το δημιουργήσει, αλλά η assert_called_with() θα κάνει raise μια εξαίρεση αποτυχίας.

Προσομοίωση Κλάσεων

Μια συνηθισμένη περίπτωση χρήσης είναι η προσομοίωση κλάσεων που δημιουργούνται από τον κώδικα υπό δοκιμή. Όταν επιδιορθώνετε (patch) μια κλάση, τότε αυτή η κλάση αντικαθίσταται με μια προσομοίωση. Τα στιγμιότυπα δημιουργούνται με την κλήση της κλάσης. Αυτό σημαίνει ότι έχετε πρόσβαση στο «στιγμιότυπο προσομοίωσης» εξετάζοντας την τιμή επιστροφής της προσομοιωμένης κλάσης.

Στο παρακάτω παράδειγμα έχουμε μια συνάρτηση some_function που δημιουργεί ένα στιγμιότυπο της Foo και καλεί μια μέθοδο σε αυτό. Η κλήση στη patch() αντικαθιστά την κλάση Foo με μια προσομοίωση. Το στιγμιότυπο της Foo είναι το αποτέλεσμα της κλήσης της προσομοίωσης, οπότε διαμορφώνεται τροποποιώντας το χαρακτηριστικό return_value της προσομοίωσης.

>>> def some_function():
...     instance = module.Foo()
...     return instance.method()
...
>>> with patch('module.Foo') as mock:
...     instance = mock.return_value
...     instance.method.return_value = 'the result'
...     result = some_function()
...     assert result == 'the result'

Ονομασία των προσομοιώσεών σας

Μπορεί να είναι χρήσιμο να δώσετε στις προσομοιώσεις σας ένα όνομα. Το όνομα εμφανίζεται στην αναπαράσταση (repr) της προσομοίωσης και μπορεί να είναι χρήσιμο όταν η προσομοίωση εμφανίζεται σε μηνύματα αποτυχίας δοκιμών. Το όνομα επίσης μεταδίδεται σε χαρακτηριστικά ή μεθόδους της προσομοίωσης:

>>> mock = MagicMock(name='foo')
>>> mock
<MagicMock name='foo' id='...'>
>>> mock.method
<MagicMock name='foo.method' id='...'>

Παρακολούθηση όλων των Κλήσεων

Συχνά θέλετε να παρακολουθείτε περισσότερες από μία κλήσεις σε μια μέθοδο. Το χαρακτηριστικό mock_calls καταγράφει όλες τις κλήσεις σε θυγατρικά χαρακτηριστικά της προσομοίωσης - και επίσης στα παιδιά τους.

>>> mock = MagicMock()
>>> mock.method()
<MagicMock name='mock.method()' id='...'>
>>> mock.attribute.method(10, x=53)
<MagicMock name='mock.attribute.method()' id='...'>
>>> mock.mock_calls
[call.method(), call.attribute.method(10, x=53)]

Εάν κάνετε μια δήλωση σχετικά με το mock_calls και έχουν κληθεί απροσδόκητες μέθοδοι, τότε η δήλωση θα αποτύχει. Αυτό είναι χρήσιμο επειδή εκτός από το να δηλώνετε ότι οι κλήσεις που περιμένατε έχουν γίνει, ελέγχετε επίσης ότι έγιναν με τη σωστή σειρά και χωρίς επιπλέον κλήσεις:

Χρησιμοποιήστε το αντικείμενο call για να κατασκευάσετε λίστες για σύγκριση με το mock_calls:

>>> expected = [call.method(), call.attribute.method(10, x=53)]
>>> mock.mock_calls == expected
True

Ωστόσο, οι παράμετροι σε κλήσεις που επιστρέφουν προσομοιώσεις δεν καταγράφονται, που σημαίνει ότι δεν είναι δυνατή η παρακολούθηση εμφωλευμένων κλήσεων όπου οι παράμετροι που χρησιμοποιούνται για τη δημιουργία προγόνων είναι σημαντικοί:

>>> m = Mock()
>>> m.factory(important=True).deliver()
<Mock name='mock.factory().deliver()' id='...'>
>>> m.mock_calls[-1] == call.factory(important=False).deliver()
True

Ορισμός Τιμών Επιστροφής και Χαρακτηριστικών

Ορισμός των τιμών επιστροφής σε ένα αντικείμενο προσομοίωσης είναι εξαιρετικά εύκολος:

>>> mock = Mock()
>>> mock.return_value = 3
>>> mock()
3

Φυσικά μπορείτε να κάνετε το ίδιο για μεθόδους στην προσομοίωση:

>>> mock = Mock()
>>> mock.method.return_value = 3
>>> mock.method()
3

Η τιμή επιστροφής μπορεί επίσης να οριστεί στον κατασκευαστή:

>>> mock = Mock(return_value=3)
>>> mock()
3

Εάν χρειάζεστε έναν ορισμό χαρακτηριστικού στην προσομοίωσή σας, απλώς κάντε το:

>>> mock = Mock()
>>> mock.x = 3
>>> mock.x
3

Μερικές φορές θέλετε να προσομοιώσετε μια πιο σύνθετη κατάσταση, όπως για παράδειγμα mock.connection.cursor().execute("SELECT 1"). Εάν θέλαμε αυτή τη κλήση να επιστρέψει μια λίστα, τότε πρέπει να διαμορφώσουμε το αποτέλεσμα της εμφωλευμένης κλήσης.

Μπορούμε να χρησιμοποιήσουμε το αντικείμενο call για να κατασκευάσουμε την λίστα των κλήσεων σε μια «αλυσιδωτή κλήση» όπως αυτή για εύκολη δήλωση αργότερα:

>>> mock = Mock()
>>> cursor = mock.connection.cursor.return_value
>>> cursor.execute.return_value = ['foo']
>>> mock.connection.cursor().execute("SELECT 1")
['foo']
>>> expected = call.connection.cursor().execute("SELECT 1").call_list()
>>> mock.mock_calls
[call.connection.cursor(), call.connection.cursor().execute('SELECT 1')]
>>> mock.mock_calls == expected
True

Είναι η κλήση στο .call_list() που μετατρέπει το αντικείμενο κλήσης σε μια λίστα κλήσεων που αντιπροσωπεύουν τις αλυσιδωτές κλήσεις.

Πρόκληση εξαιρέσεων με προσομοιώσεις

Ένα χρήσιμο χαρακτηριστικό είναι το side_effect. Εάν το ορίσετε σε μια κλάση εξαίρεσης ή ένα στιγμιότυπο, τότε η εξαίρεση θα γίνει raise όταν κληθεί η προσομοίωση.

>>> mock = Mock(side_effect=Exception('Boom!'))
>>> mock()
Traceback (most recent call last):
  ...
Exception: Boom!

Συναρτήσεις παρενέργειας και iterables

Το side_effect μπορεί επίσης να οριστεί σε μια συνάρτηση ή ένα iterable. Η χρήση του side_effect ως iterable είναι όταν η προσομοίωσή σας πρόκειται να κληθεί αρκετές φορές, και θέλετε κάθε κλήση να επιστρέφει μια διαφορετική τιμή. Όταν ορίζετε το side_effect σε ένα iterable, κάθε κλήση στην προσομοίωση επιστρέφει την επόμενη τιμή από το iterable:

>>> mock = MagicMock(side_effect=[4, 5, 6])
>>> mock()
4
>>> mock()
5
>>> mock()
6

Για πιο προηγμένες χρήσεις, όπως η δυναμική μεταβολή των τιμών επιστροφής ανάλογα με το πώς καλείται η προσομοίωση, το side_effect μπορεί να είναι μια συνάρτηση. Η συνάρτηση θα κληθεί με τα ίδια ορίσματα με την προσομοίωση. Ό,τι επιστρέφει η συνάρτηση είναι αυτό που επιστρέφει η κλήση:

>>> vals = {(1, 2): 1, (2, 3): 2}
>>> def side_effect(*args):
...     return vals[args]
...
>>> mock = MagicMock(side_effect=side_effect)
>>> mock(1, 2)
1
>>> mock(2, 3)
2

Προσομοίωση ασύγχρονων επαναληπτών

Από την έκδοση Python 3.8, οι AsyncMock και MagicMock έχουν υποστήριξη για την προσομοίωση ασύγχρονων επαναληπτών μέσω του __aiter__. Το χαρακτηριστικό return_value του __aiter__ μπορεί να χρησιμοποιηθεί για να ορίσει τις τιμές επιστροφής που θα χρησιμοποιηθούν για την επανάληψη.

>>> mock = MagicMock()  # AsyncMock also works here
>>> mock.__aiter__.return_value = [1, 2, 3]
>>> async def main():
...     return [i async for i in mock]
...
>>> asyncio.run(main())
[1, 2, 3]

Προσομοίωση ασύγχρονου διαχειριστή περιεχομένου

Από την έκδοση Python 3.8, οι AsyncMock και MagicMock έχουν υποστήριξη για την προσομοίωση ασύγχρονων διαχειριστών μέσω των __aenter__ και __aexit__. Από προεπιλογή, οι __aenter__ και __aexit__ είναι στιγμιότυπα AsyncMock που επιστρέφουν μια ασύγχρονη συνάρτηση.

>>> class AsyncContextManager:
...     async def __aenter__(self):
...         return self
...     async def __aexit__(self, exc_type, exc, tb):
...         pass
...
>>> mock_instance = MagicMock(AsyncContextManager())  # AsyncMock also works here
>>> async def main():
...     async with mock_instance as result:
...         pass
...
>>> asyncio.run(main())
>>> mock_instance.__aenter__.assert_awaited_once()
>>> mock_instance.__aexit__.assert_awaited_once()

Δημιουργία Προσομοίωσης από ένα Υφιστάμενο Αντικείμενο

Ένα πρόβλημα με την υπερβολική χρήση της προσομοίωσης είναι ότι συνδέει τις δοκιμές σας με την υλοποίηση των προσομοιώσεών σας αντί με τον πραγματικό κώδικα. Υποθέστε ότι έχετε μια κλάση που υλοποιεί την some_method. Σε μια δοκιμή για μια άλλη κλάση, παρέχετε μια προσομοίωση αυτού του αντικειμένου που επίσης παρέχει την some_method. Εάν αργότερα αναδιαρθρώσετε την πρώτη κλάση, έτσι ώστε να μην έχει πλέον την some_method - τότε οι δοκιμές σας θα συνεχίσουν να περνούν, παρόλο που ο κώδικάς σας είναι τώρα σπασμένος!

Mock σας επιτρέπει να παρέχετε ένα αντικείμενο ως προδιαγραφή για την προσομοίωση, χρησιμοποιώντας το όρισμα λέξης-κλειδιού spec. Η πρόσβαση σε μεθόδους / χαρακτηριστικά στην προσομοίωση που δεν υπάρχουν στο αντικείμενο προδιαγραφής σας θα γίνει raise αμέσως ένα σφάλμα χαρακτηριστικού. Εάν αλλάξετε την υλοποίηση της προδιαγραφής σας, τότε οι δοκιμές που χρησιμοποιούν αυτή την κλάση θα αρχίσουν να αποτυγχάνουν αμέσως χωρίς να χρειάζεται να δημιουργήσετε ένα στιγμιότυπο της κλάσης σε αυτές τις δοκιμές.

>>> mock = Mock(spec=SomeClass)
>>> mock.old_method()
Traceback (most recent call last):
   ...
AttributeError: Mock object has no attribute 'old_method'. Did you mean: 'class_method'?

Η χρήση μιας προδιαγραφής επιτρέπει επίσης μια πιο έξυπνη αντιστοίχιση των κλήσεων που γίνονται στην προσομοίωση, ανεξάρτητα από το αν ορισμένες παράμετροι περάστηκαν ως ορισμένες ή ονομαστικές παραμέτρους:

>>> def f(a, b, c): pass
...
>>> mock = Mock(spec=f)
>>> mock(1, 2, 3)
<Mock name='mock()' id='140161580456576'>
>>> mock.assert_called_with(a=1, b=2, c=3)

Εάν θέλετε αυτή η πιο έξυπνη αντιστοίχιση να λειτουργεί επίσης με κλήσεις μεθόδων στην προσομοίωση, μπορείτε να χρησιμοποιήσετε auto-speccing.

Εάν θέλετε μια πιο ισχυρή μορφή προδιαγραφής που αποτρέπει τον ορισμό αυθαίρετων χαρακτηριστικών καθώς και την πρόσβαση σε αυτά, τότε μπορείτε να χρησιμοποιήσετε το spec_set αντί για το spec.

Χρήση του side_effect για επιστροφή περιεχομένου ανά αρχείο

Η mock_open() χρησιμοποιείται για την επιδιόρθωση (patch) της open() μεθόδου. Το side_effect μπορεί να χρησιμοποιηθεί για την επιστροφή ενός νέου αντικειμένου Mock ανά κλήση. Αυτό μπορεί να χρησιμοποιηθεί για την επιστροφή διαφορετικών περιεχομένων ανά αρχείο που αποθηκεύονται σε ένα λεξικό:

DEFAULT = "default"
data_dict = {"file1": "data1",
             "file2": "data2"}

def open_side_effect(name):
    return mock_open(read_data=data_dict.get(name, DEFAULT))()

with patch("builtins.open", side_effect=open_side_effect):
    with open("file1") as file1:
        assert file1.read() == "data1"

    with open("file2") as file2:
        assert file2.read() == "data2"

    with open("file3") as file2:
        assert file2.read() == "default"

Διακοσμητές Επιδιόρθωσης (Patch Decorators)

Σημείωση

Με την patch() έχει σημασία να επιδιορθώνετε αντικείμενα στο χώρο ονομάτων όπου αναζητούνται. Αυτό είναι συνήθως απλό, αλλά για έναν γρήγορο οδηγό διαβάστε where to patch.

Μια κοινή ανάγκη στις δοκιμές είναι να επιδιορθώσετε ένα χαρακτηριστικό κλάσης ή ένα χαρακτηριστικό μονάδας, για παράδειγμα επιδιόρθωση ενός ενσωματωμένου ή επιδιόρθωση μιας κλάσης σε μια μονάδα για να ελέγξετε ότι δημιουργείται. Οι μονάδες και οι κλάσεις είναι ουσιαστικά παγκόσμιες, οπότε η επιδιόρθωση σε αυτές πρέπει να αναιρεθεί μετά τη δοκιμή ή η επιδιόρθωση θα επιμείνει σε άλλες δοκιμές και θα προκαλέσει προβλήματα που είναι δύσκολα να διαγνωστούν.

Η προσομοίωση παρέχει τρεις βολικούς διακοσμητές για αυτό: patch(), patch.object() και patch.dict(). Η patch παίρνει μια μοναδική συμβολοσειρά, της μορφής package.module.Class.attribute για να καθορίσει το χαρακτηριστικό που επιδιορθώνετε. Επίσης παίρνει προαιρετικά μια τιμή με την οποία θέλετε να αντικατασταθεί το χαρακτηριστικό (ή η κλάση ή οτιδήποτε). “patch.object” παίρνει ένα αντικείμενο και το όνομα του χαρακτηριστικού που θα θέλατε να επιδιορθώσετε, συν προαιρετικά την τιμή με την οποία θα το επιδιορθώσετε.

patch.object:

>>> original = SomeClass.attribute
>>> @patch.object(SomeClass, 'attribute', sentinel.attribute)
... def test():
...     assert SomeClass.attribute == sentinel.attribute
...
>>> test()
>>> assert SomeClass.attribute == original

>>> @patch('package.module.attribute', sentinel.attribute)
... def test():
...     from package.module import attribute
...     assert attribute is sentinel.attribute
...
>>> test()

Εάν επιδιορθώνετε ένα module (συμπεριλαμβανομένου του builtins), τότε χρησιμοποιήστε την patch() αντί για την patch.object():

>>> mock = MagicMock(return_value=sentinel.file_handle)
>>> with patch('builtins.open', mock):
...     handle = open('filename', 'r')
...
>>> mock.assert_called_with('filename', 'r')
>>> assert handle == sentinel.file_handle, "incorrect file handle returned"

Το όνομα του module μπορεί να είναι “τελεία”, με τη μορφή package.module εάν χρειάζεται:

>>> @patch('package.module.ClassName.attribute', sentinel.attribute)
... def test():
...     from package.module import ClassName
...     assert ClassName.attribute == sentinel.attribute
...
>>> test()

Ένα ωραίο μοτίβο είναι να διακοσμείτε πραγματικά τις μεθόδους δοκιμής:

>>> class MyTest(unittest.TestCase):
...     @patch.object(SomeClass, 'attribute', sentinel.attribute)
...     def test_something(self):
...         self.assertEqual(SomeClass.attribute, sentinel.attribute)
...
>>> original = SomeClass.attribute
>>> MyTest('test_something').test_something()
>>> assert SomeClass.attribute == original

Εάν θέλετε να επιδιορθώσετε με μια προσομοίωση, μπορείτε να χρησιμοποιήσετε patch() με μόνο ένα όρισμα (ή patch.object() με δύο ορίσματα). Η προσομοίωση θα δημιουργηθεί για εσάς και θα περαστεί στη συνάρτηση / μέθοδο δοκιμής:

>>> class MyTest(unittest.TestCase):
...     @patch.object(SomeClass, 'static_method')
...     def test_something(self, mock_method):
...         SomeClass.static_method()
...         mock_method.assert_called_with()
...
>>> MyTest('test_something').test_something()

Μπορείτε να στοιβάξετε πολλαπλούς διακοσμητές επιδιόρθωσης χρησιμοποιώντας

>>> class MyTest(unittest.TestCase):
...     @patch('package.module.ClassName1')
...     @patch('package.module.ClassName2')
...     def test_something(self, MockClass2, MockClass1):
...         self.assertIs(package.module.ClassName1, MockClass1)
...         self.assertIs(package.module.ClassName2, MockClass2)
...
>>> MyTest('test_something').test_something()

Όταν εμφωλεύετε διακοσμητές επιδιόρθωσης, οι προσομοιώσεις περνιούνται στη διακοσμημένη συνάρτηση με την ίδια σειρά που εφαρμόστηκαν (η κανονική τάξη Python με την οποία εφαρμόζονται οι διακοσμητές). Αυτό σημαίνει από κάτω προς τα πάνω, οπότε στο παραπάνω παράδειγμα η προσομοίωση για το test_module.ClassName2 περνάει πρώτη.

Υπάρχει επίσης η patch.dict() για τον ορισμό τιμών σε ένα λεξικό μόνο κατά τη διάρκεια ενός πεδίου και την αποκατάσταση του λεξικού στην αρχική του κατάσταση όταν τελειώνει η δοκιμή:

>>> foo = {'key': 'value'}
>>> original = foo.copy()
>>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):
...     assert foo == {'newkey': 'newvalue'}
...
>>> assert foo == original

Η patch, η patch.object και η patch.dict μπορούν όλες να χρησιμοποιηθούν ως διαχειριστές συμφραζομένων.

Όπου χρησιμοποιείτε την patch() για να δημιουργήσετε μια προσομοίωση για εσάς, μπορείτε να λάβετε μια αναφορά στην προσομοίωση χρησιμοποιώντας τη μορφή «as» της δήλωσης with:

>>> class ProductionClass:
...     def method(self):
...         pass
...
>>> with patch.object(ProductionClass, 'method') as mock_method:
...     mock_method.return_value = None
...     real = ProductionClass()
...     real.method(1, 2, 3)
...
>>> mock_method.assert_called_with(1, 2, 3)

Ως εναλλακτική, η patch, η patch.object και η patch.dict μπορούν να χρησιμοποιηθούν ως διακοσμητές κλάσης. Όταν χρησιμοποιούνται με αυτόν τον τρόπο, είναι το ίδιο με την εφαρμογή του διακοσμητή ξεχωριστά σε κάθε μέθοδο του οποίου το όνομα ξεκινά με «test».

Περαιτέρω Παραδείγματα

Εδώ είναι μερικά ακόμη παραδείγματα για μερικά ελαφρώς πιο προηγμένα σενάρια.

Προσομοίωση αλυσιδωτών κλήσεων

Η προσομοίωση αλυσιδωτών κλήσεων είναι στην πραγματικότητα απλή με την προσομοίωση μόλις κατανοήσετε το χαρακτηριστικό return_value. Όταν καλείται μια προσομοίωση για πρώτη φορά, ή λαμβάνετε την return_value της πριν καλεστεί, δημιουργείται μια νέα Mock.

Αυτό σημαίνει ότι μπορείτε να δείτε πώς έχει χρησιμοποιηθεί το αντικείμενο που επιστρέφεται από μια κλήση σε ένα προσομοιωμένο αντικείμενο, εξετάζοντας την προσομοίωση return_value:

>>> mock = Mock()
>>> mock().foo(a=2, b=3)
<Mock name='mock().foo()' id='...'>
>>> mock.return_value.foo.assert_called_with(a=2, b=3)

Από εδώ είναι ένα απλό βήμα για τη διαμόρφωση και στη συνέχεια τη δημιουργία δηλώσεων σχετικά με τις αλυσιδωτές κλήσεις. Φυσικά μια άλλη εναλλακτική είναι να γράψετε τον κώδικά σας με πιο δοκιμαστικό τρόπο από την αρχή…

Λοιπόν, υποθέτουμε ότι έχουμε κάποιο κώδικα που μοιάζει λίγο με αυτό:

>>> class Something:
...     def __init__(self):
...         self.backend = BackendProvider()
...     def method(self):
...         response = self.backend.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
...         # more code

Υποθέτοντας ότι το BackendProvider έχει ήδη δοκιμαστεί καλά, πώς δοκιμάζουμε τη method(); Συγκεκριμένα, θέλουμε να δοκιμάσουμε ότι η ενότητα κώδικα # more code χρησιμοποιεί το αντικείμενο απόκρισης με τον σωστό τρόπο.

Καθώς αυτή η αλυσίδα κλήσεων γίνεται από ένα χαρακτηριστικό στιγμιότυπου, μπορούμε να επιδιορθώσουμε (monkey patch) το χαρακτηριστικό backend σε ένα στιγμιότυπο Something. Σε αυτή την συγκεκριμένη περίπτωση, μας ενδιαφέρει μόνο η τιμή επιστροφής από την τελική κλήση στο start_call, οπότε δεν έχουμε πολλή διαμόρφωση να κάνουμε. Ας υποθέσουμε ότι το αντικείμενο που επιστρέφει είναι “σαν αρχείο”, οπότε θα διασφαλίσουμε ότι το αντικείμενο απόκρισης μας χρησιμοποιεί την ενσωματωμένη open() ως το spec της.

Για να το κάνουμε αυτό, δημιουργούμε ένα στιγμιότυπο προσομοίωσης ως το mock backend μας και δημιουργούμε ένα αντικείμενο προσομοίωσης απόκρισης για αυτό. Για να ορίσουμε την απόκριση ως την τιμή επιστροφής για εκείνο το τελικό start_call, θα μπορούσαμε να κάνουμε αυτό:

mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response

Μπορούμε να το κάνουμε με έναν ελαφρώς πιο ωραίο τρόπο χρησιμοποιώντας τη configure_mock() μέθοδο για να ορίσουμε απευθείας την τιμή επιστροφής για εμάς:

>>> something = Something()
>>> mock_response = Mock(spec=open)
>>> mock_backend = Mock()
>>> config = {'get_endpoint.return_value.create_call.return_value.start_call.return_value': mock_response}
>>> mock_backend.configure_mock(**config)

Με αυτά, επιδιορθώνουμε (monkey patch) το «mock backend» στη θέση του και μπορούμε να κάνουμε την πραγματική κλήση:

>>> something.backend = mock_backend
>>> something.method()

Με το χαρακτηριστικό mock_calls μπορούμε να ελέγξουμε την αλυσιδωτή κλήση με μια μοναδική δήλωση. Μια αλυσιδωτή κλήση είναι πολλές κλήσεις σε μία γραμμή κώδικα, οπότε θα υπάρχουν πολλές εισαγωγές στο mock_calls. Μπορούμε να χρησιμοποιήσουμε τη call.call_list() για να δημιουργήσουμε αυτή τη λίστα κλήσεων για εμάς:

>>> chained = call.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
>>> call_list = chained.call_list()
>>> assert mock_backend.mock_calls == call_list

Μερική προσομοίωση

Για ορισμένες δοκιμές, μπορεί να θέλετε να προσομοιώσετε μια κλήση στη datetime.date.today() για να επιστρέψετε μια γνωστή ημερομηνία, αλλά δεν θέλετε να αποτρέψετε τον κώδικα υπό δοκιμή από τη δημιουργία νέων αντικειμένων ημερομηνίας. Δυστυχώς, η datetime.date είναι γραμμένη σε C, οπότε δεν μπορείτε απλώς να κάνετε monkey-patch στη στατική datetime.date.today() μέθοδο.

Αντίθετα, μπορείτε ουσιαστικά να τυλίξετε την κλάση ημερομηνίας με μια προσομοίωση, ενώ περνάτε κλήσεις στον κατασκευαστή στην πραγματική κλάση (και επιστρέφοντας πραγματικά στιγμιότυπα).

Η patch decorator χρησιμοποιείται εδώ για να επιδιορθώσετε την κλάση ημερομηνίας στο μοντέλο υπό δοκιμή. Το χαρακτηριστικό side_effect στην προσομοίωση της κλάσης ημερομηνίας ρυθμίζεται στη συνέχεια σε μια συνάρτηση λάμδα που επιστρέφει μια πραγματική ημερομηνία. Όταν καλείται η προσομοίωση της κλάσης ημερομηνίας, θα κατασκευαστεί και θα επιστραφεί μια πραγματική ημερομηνία από το side_effect.

>>> from datetime import date
>>> with patch('mymodule.date') as mock_date:
...     mock_date.today.return_value = date(2010, 10, 8)
...     mock_date.side_effect = lambda *args, **kw: date(*args, **kw)
...
...     assert mymodule.date.today() == date(2010, 10, 8)
...     assert mymodule.date(2009, 6, 8) == date(2009, 6, 8)

Σημειώστε ότι δεν επιδιορθώνουμε παγκοσμίως την datetime.date, αλλά επιδιορθώνουμε την date στο μοντέλο που τη χρησιμοποιεί. Δείτε where to patch.

Όταν καλείται το date.today(), επιστρέφεται μια γνωστή ημερομηνία, αλλά οι κλήσεις στον κατασκευαστή date(...) εξακολουθούν να επιστρέφουν κανονικές ημερομηνίες. Χωρίς αυτό, μπορεί να βρεθείτε να πρέπει να υπολογίσετε ένα αναμενόμενο αποτέλεσμα χρησιμοποιώντας ακριβώς τον ίδιο αλγόριθμο με τον κώδικα υπό δοκιμή, που είναι ένα κλασικό αντι-μοτίβο δοκιμών.

Οι κλήσεις στον κατασκευαστή ημερομηνίας καταγράφονται στα χαρακτηριστικά του mock_date (call_count και φίλοι), τα οποία μπορεί επίσης να είναι χρήσιμα για τις δοκιμές σας.

Ένας εναλλακτικός τρόπος αντιμετώπισης της προσομοίωσης ημερομηνιών ή άλλων ενσωματωμένων κλάσεων, συζητείται σε αυτή την καταχώρηση ιστολογίου.

Προσομοίωση μιας Μεθόδου Γεννήτριας

Μια γεννήτρια Python είναι μια συνάρτηση ή μέθοδος που χρησιμοποιεί τη yield δήλωση για να επιστρέψει μια σειρά τιμών όταν γίνεται επανάληψη πάνω της [1].

Μια μέθοδος / συνάρτηση γεννήτριας καλείται για να επιστρέψει το αντικείμενο γεννήτριας. Είναι το αντικείμενο γεννήτριας που στη συνέχεια επαναλαμβάνεται. Η μέθοδος πρωτοκόλλου για την επανάληψη είναι η __iter__(), οπότε μπορούμε να την προσομοιώσουμε χρησιμοποιώντας μια MagicMock.

Εδώ είναι ένα παράδειγμα κλάσης με μια μέθοδο «iter» που υλοποιείται ως γεννήτρια:

>>> class Foo:
...     def iter(self):
...         for i in [1, 2, 3]:
...             yield i
...
>>> foo = Foo()
>>> list(foo.iter())
[1, 2, 3]

Πώς θα προσομοιώναμε αυτή την κλάση, και συγκεκριμένα τη μέθοδο της «iter»;

Για να διαμορφώσουμε τις τιμές που επιστρέφονται από την επανάληψη (ρητά στην κλήση στη list), πρέπει να διαμορφώσουμε το αντικείμενο που επιστρέφεται από την κλήση στο foo.iter().

>>> mock_foo = MagicMock()
>>> mock_foo.iter.return_value = iter([1, 2, 3])
>>> list(mock_foo.iter())
[1, 2, 3]

[1]

Υπάρχουν επίσης εκφράσεις γεννητριών και πιο προηγμένες χρήσεις γεννητριών, αλλά δεν μας απασχολούν εδώ. Μια πολύ καλή εισαγωγή στις γεννήτριες και πόσο ισχυρές είναι: Generator Tricks for Systems Programmers.

Εφαρμογή της ίδιας επιδιόρθωσης σε κάθε μέθοδο δοκιμής

Εάν θέλετε να υπάρχουν πολλές επιδιορθώσεις για πολλαπλές μεθόδους δοκιμής, ο προφανής τρόπος είναι να εφαρμόσετε τους διακοσμητές επιδιόρθωσης σε κάθε μέθοδο. Αυτό μπορεί να φαίνεται σαν περιττή επανάληψη. Αντίθετα, μπορείτε να χρησιμοποιήσετε την patch() (σε όλες τις διάφορες μορφές της) ως διακοσμητή κλάσης. Αυτό εφαρμόζει τις επιδιορθώσεις σε όλες τις μεθόδους δοκιμής στην κλάση. Μια μέθοδος δοκιμής αναγνωρίζεται από μεθόδους των οποίων τα ονόματα ξεκινούν με test:

>>> @patch('mymodule.SomeClass')
... class MyTest(unittest.TestCase):
...
...     def test_one(self, MockSomeClass):
...         self.assertIs(mymodule.SomeClass, MockSomeClass)
...
...     def test_two(self, MockSomeClass):
...         self.assertIs(mymodule.SomeClass, MockSomeClass)
...
...     def not_a_test(self):
...         return 'something'
...
>>> MyTest('test_one').test_one()
>>> MyTest('test_two').test_two()
>>> MyTest('test_two').not_a_test()
'something'

Ένας εναλλακτικός τρόπος διαχείρισης των επιδιορθώσεων είναι η χρήση των patch methods: start and stop. Αυτά σας επιτρέπουν να μετακινήσετε την επιδιόρθωση στις μεθόδους σας setUp και tearDown.

>>> class MyTest(unittest.TestCase):
...     def setUp(self):
...         self.patcher = patch('mymodule.foo')
...         self.mock_foo = self.patcher.start()
...
...     def test_foo(self):
...         self.assertIs(mymodule.foo, self.mock_foo)
...
...     def tearDown(self):
...         self.patcher.stop()
...
>>> MyTest('test_foo').run()

Εάν χρησιμοποιήσετε αυτήν την τεχνική, πρέπει να διασφαλίσετε ότι η επιδιόρθωση αναιρείται καλώντας το stop. Αυτό μπορεί να είναι πιο περίπλοκο από ό,τι μπορεί να νομίζετε, επειδή εάν γίνει raise μια εξαίρεση στο setUp, τότε το tearDown δεν καλείται. Η unittest.TestCase.addCleanup() καθιστά αυτό πιο εύκολο:

>>> class MyTest(unittest.TestCase):
...     def setUp(self):
...         patcher = patch('mymodule.foo')
...         self.addCleanup(patcher.stop)
...         self.mock_foo = patcher.start()
...
...     def test_foo(self):
...         self.assertIs(mymodule.foo, self.mock_foo)
...
>>> MyTest('test_foo').run()

Προσομοίωση Μη Δεσμευμένων Μεθόδων

Μερικές φορές μια δοκιμή χρειάζεται να επιδιορθώσει μια μη δεσμευμένη μέθοδο, που σημαίνει την επιδιόρθωση της μεθόδου στην κλάση αντί για το στιγμιότυπο. Για να κάνετε δηλώσεις σχετικά με το ποια αντικείμενα καλούσαν αυτή τη συγκεκριμένη μέθοδο, πρέπει να περάσετε το self ως πρώτο όρισμα. Το πρόβλημα είναι ότι δεν μπορείτε να επιδιορθώσετε με μια προσομοίωση για αυτό, επειδή αν αντικαταστήσετε μια μη δεσμευμένη μέθοδο με μια προσομοίωση, δεν γίνεται δεσμευμένη μέθοδος όταν ανακτάται από το στιγμιότυπο, και έτσι δεν περνάει το self. Η λύση είναι να επιδιορθώσετε τη μη δεσμευμένη μέθοδο με μια πραγματική συνάρτηση αντί για αυτό. Ο διακοσμητής patch() το καθιστά τόσο απλό να επιδιορθώνετε μεθόδους με μια προσομοίωση που η ανάγκη δημιουργίας μιας πραγματικής συνάρτησης γίνεται ενοχλητική.

Εάν περάσετε το autospec=True στην επιδιόρθωση, τότε γίνεται η επιδιόρθωση με ένα πραγματικό αντικείμενο συνάρτησης. Αυτό το αντικείμενο συνάρτησης έχει την ίδια υπογραφή με αυτό που αντικαθιστά, αλλά αναθέτει σε μια προσομοίωση κάτω από την κουκούλα. Ακόμα λαμβάνετε την προσομοίωσή σας που δημιουργείται αυτόματα με ακριβώς τον ίδιο τρόπο όπως πριν. Αυτό που σημαίνει, όμως, είναι ότι αν το χρησιμοποιήσετε για να επιδιορθώσετε μια μη δεσμευμένη μέθοδο σε μια κλάση, η προσομοιωμένη συνάρτηση θα μετατραπεί σε δεσμευμένη μέθοδο εάν ανακτηθεί από ένα στιγμιότυπο. Θα έχει το self που περνάει ως πρώτο όρισμα, που είναι ακριβώς αυτό που χρειαζόταν:

>>> class Foo:
...   def foo(self):
...     pass
...
>>> with patch.object(Foo, 'foo', autospec=True) as mock_foo:
...   mock_foo.return_value = 'foo'
...   foo = Foo()
...   foo.foo()
...
'foo'
>>> mock_foo.assert_called_once_with(foo)

Εάν δεν χρησιμοποιήσουμε το autospec=True, τότε η μη δεσμευμένη μέθοδος επιδιορθώνεται με ένα στιγμιότυπο Mock αντίθετα, και δεν καλείται με το self.

Έλεγχος πολλαπλών κλήσεων με προσομοίωση

Η προσομοίωση έχει ένα ωραίο API για τη δημιουργία δηλώσεων σχετικά με το πώς χρησιμοποιούνται τα αντικείμενα προσομοίωσής σας.

>>> mock = Mock()
>>> mock.foo_bar.return_value = None
>>> mock.foo_bar('baz', spam='eggs')
>>> mock.foo_bar.assert_called_with('baz', spam='eggs')

Εάν η προσομοίωσή σας καλείται μόνο μία φορά, μπορείτε να χρησιμοποιήσετε τη assert_called_once_with() μέθοδο που επίσης δηλώνει ότι το call_count είναι ένα.

>>> mock.foo_bar.assert_called_once_with('baz', spam='eggs')
>>> mock.foo_bar()
>>> mock.foo_bar.assert_called_once_with('baz', spam='eggs')
Traceback (most recent call last):
    ...
AssertionError: Expected 'foo_bar' to be called once. Called 2 times.
Calls: [call('baz', spam='eggs'), call()].

Και οι δύο assert_called_with και assert_called_once_with κάνουν δηλώσεις σχετικά με την τελευταία κλήση. Εάν η προσομοίωσή σας πρόκειται να καλείται πολλές φορές, και θέλετε να κάνετε δηλώσεις σχετικά με όλες αυτές τις κλήσεις, μπορείτε να χρησιμοποιήσετε το call_args_list:

>>> mock = Mock(return_value=None)
>>> mock(1, 2, 3)
>>> mock(4, 5, 6)
>>> mock()
>>> mock.call_args_list
[call(1, 2, 3), call(4, 5, 6), call()]

Ο βοηθός call καθιστά εύκολο να κάνετε δηλώσεις σχετικά με αυτές τις κλήσεις. Μπορείτε να δημιουργήσετε μια λίστα με τις αναμενόμενες κλήσεις και να τη συγκρίνετε με το call_args_list. Αυτό μοιάζει αξιοσημείωτα με το repr του call_args_list:

>>> expected = [call(1, 2, 3), call(4, 5, 6), call()]
>>> mock.call_args_list == expected
True

Αντιμετώπιση μεταβλητών ορισμάτων

Μια άλλη κατάσταση που είναι σπάνια, αλλά μπορεί να σας δαγκώσει, είναι όταν η προσομοίωσή σας καλείται με μεταβλητά ορίσματα. Το call_args και το call_args_list αποθηκεύουν αναφορές στα ορίσματα. Εάν τα ορίσματα μεταβλητοποιηθούν από τον κώδικα υπό δοκιμή, τότε δεν μπορείτε πλέον να κάνετε δηλώσεις σχετικά με το ποιες ήταν οι τιμές όταν κλήθηκε η προσομοίωση.

Εδώ είναι μερικοί παραδείγματα κώδικα που δείχνουν το πρόβλημα. Φανταστείτε τις παρακάτω συναρτήσεις ορισμένες στο “mymodule”:

def frob(val):
    pass

def grob(val):
    "First frob and then clear val"
    frob(val)
    val.clear()

Όταν προσπαθήσουμε να δοκιμάσουμε ότι το grob καλεί το frob με το σωστό όρισμα, δείτε τι συμβαίνει:

>>> with patch('mymodule.frob') as mock_frob:
...     val = {6}
...     mymodule.grob(val)
...
>>> val
set()
>>> mock_frob.assert_called_with({6})
Traceback (most recent call last):
    ...
AssertionError: Expected: (({6},), {})
Called with: ((set(),), {})

Μια πιθανότητα θα ήταν για την προσομοίωση να αντιγράψει τα ορίσματα που περνάτε. Αυτό θα μπορούσε στη συνέχεια να προκαλέσει προβλήματα εάν κάνετε δηλώσεις που βασίζονται στην ταυτότητα αντικειμένου για την ισότητα.

Εδώ είναι μια λύση που χρησιμοποιεί τη λειτουργικότητα side_effect. Εάν παρέχετε μια συνάρτηση side_effect για μια προσομοίωση, τότε το side_effect θα κληθεί με τα ίδια ορίσματα με την προσομοίωση. Αυτό μας δίνει μια ευκαιρία να αντιγράψουμε τα ορίσματα και να τα αποθηκεύσουμε για μετέπειτα δηλώσεις. Σε αυτό το παράδειγμα, χρησιμοποιώ άλλη προσομοίωση για να αποθηκεύσω τα ορίσματα, ώστε να μπορώ να χρησιμοποιήσω τις μεθόδους προσομοίωσης για να κάνω τη δήλωση. Και πάλι, μια βοηθητική συνάρτηση το ρυθμίζει για μένα.

>>> from copy import deepcopy
>>> from unittest.mock import Mock, patch, DEFAULT
>>> def copy_call_args(mock):
...     new_mock = Mock()
...     def side_effect(*args, **kwargs):
...         args = deepcopy(args)
...         kwargs = deepcopy(kwargs)
...         new_mock(*args, **kwargs)
...         return DEFAULT
...     mock.side_effect = side_effect
...     return new_mock
...
>>> with patch('mymodule.frob') as mock_frob:
...     new_mock = copy_call_args(mock_frob)
...     val = {6}
...     mymodule.grob(val)
...
>>> new_mock.assert_called_with({6})
>>> new_mock.call_args
call({6})

Το copy_call_args καλείται με την προσομοίωση που θα κληθεί. Επιστρέφει μια νέα προσομοίωση στην οποία κάνουμε τη δήλωση. Η συνάρτηση side_effect κάνει ένα αντίγραφο των ορισμάτων και καλεί τη new_mock με το αντίγραφο.

Σημείωση

Εάν η προσομοίωσή σας πρόκειται να χρησιμοποιηθεί μόνο μία φορά, υπάρχει ένας ευκολότερος τρόπος ελέγχου των ορισμάτων στο σημείο που καλούνται. Μπορείτε απλά να κάνετε τον έλεγχο μέσα σε μια side_effect συνάρτηση.

>>> def side_effect(arg):
...     assert arg == {6}
...
>>> mock = Mock(side_effect=side_effect)
>>> mock({6})
>>> mock(set())
Traceback (most recent call last):
    ...
AssertionError

Μια εναλλακτική προσέγγιση είναι να δημιουργήσετε μια υποκλάση της Mock ή MagicMock που αντιγράφει (χρησιμοποιώντας τη copy.deepcopy()) τα ορίσματα. Εδώ είναι ένα παράδειγμα υλοποίησης:

>>> from copy import deepcopy
>>> class CopyingMock(MagicMock):
...     def __call__(self, /, *args, **kwargs):
...         args = deepcopy(args)
...         kwargs = deepcopy(kwargs)
...         return super().__call__(*args, **kwargs)
...
>>> c = CopyingMock(return_value=None)
>>> arg = set()
>>> c(arg)
>>> arg.add(1)
>>> c.assert_called_with(set())
>>> c.assert_called_with(arg)
Traceback (most recent call last):
    ...
AssertionError: expected call not found.
Expected: mock({1})
Actual: mock(set())
>>> c.foo
<CopyingMock name='mock.foo' id='...'>

Όταν υποκλάσετε το Mock ή το MagicMock, όλα τα δυναμικά δημιουργημένα χαρακτηριστικά, και το return_value θα χρησιμοποιούν την υποκλάση σας αυτόματα. Αυτό σημαίνει ότι όλα τα παιδιά ενός CopyingMock θα έχουν επίσης τον τύπο CopyingMock.

Εμφωλευμένες Επιδιορθώσεις

Η χρήση της επιδιόρθωσης ως διαχειριστής περιβάλλοντος είναι ωραία, αλλά αν κάνετε πολλαπλές επιδιορθώσεις, μπορεί να καταλήξετε με επικαλυπτόμενες δηλώσεις with που εσοχίζουν όλο και περισσότερο προς τα δεξιά:

>>> class MyTest(unittest.TestCase):
...
...     def test_foo(self):
...         with patch('mymodule.Foo') as mock_foo:
...             with patch('mymodule.Bar') as mock_bar:
...                 with patch('mymodule.Spam') as mock_spam:
...                     assert mymodule.Foo is mock_foo
...                     assert mymodule.Bar is mock_bar
...                     assert mymodule.Spam is mock_spam
...
>>> original = mymodule.Foo
>>> MyTest('test_foo').test_foo()
>>> assert mymodule.Foo is original

Με τις λειτουργίες καθαρισμού του unittest και το patch methods: start and stop μπορούμε να επιτύχουμε το ίδιο αποτέλεσμα χωρίς την εμφωλευμένη εσοχή. Μια απλή βοηθητική μέθοδος, create_patch, τοποθετεί την επιδιόρθωση στη θέση της και επιστρέφει την δημιουργημένη προσομοίωση για εμάς:

>>> class MyTest(unittest.TestCase):
...
...     def create_patch(self, name):
...         patcher = patch(name)
...         thing = patcher.start()
...         self.addCleanup(patcher.stop)
...         return thing
...
...     def test_foo(self):
...         mock_foo = self.create_patch('mymodule.Foo')
...         mock_bar = self.create_patch('mymodule.Bar')
...         mock_spam = self.create_patch('mymodule.Spam')
...
...         assert mymodule.Foo is mock_foo
...         assert mymodule.Bar is mock_bar
...         assert mymodule.Spam is mock_spam
...
>>> original = mymodule.Foo
>>> MyTest('test_foo').run()
>>> assert mymodule.Foo is original

Προσομοίωση ενός λεξικού με το MagicMock

Ίσως θέλετε να προσομοιώσετε ένα λεξικό ή άλλο αντικείμενο κοντέινερ, καταγράφοντας όλη την πρόσβαση σε αυτό, ενώ εξακολουθεί να συμπεριφέρεται σαν λεξικό.

Μπορούμε να το κάνουμε αυτό με την MagicMock, η οποία θα συμπεριφέρεται σαν λεξικό, και χρησιμοποιώντας το side_effect για να αναθέσουμε την πρόσβαση στο λεξικό σε ένα πραγματικό υποκείμενο λεξικό που είναι υπό τον έλεγχό μας.

Όταν οι μέθοδοι __getitem__() και __setitem__() του MagicMock μας καλούνται (κανονική πρόσβαση λεξικού), τότε το side_effect καλείται με το κλειδί (και στην περίπτωση του __setitem__ και την τιμή επίσης). Μπορούμε επίσης να ελέγξουμε τι επιστρέφεται.

Μετά τη χρήση του MagicMock, μπορούμε να χρησιμοποιήσουμε χαρακτηριστικά όπως το call_args_list για να κάνουμε δηλώσεις σχετικά με το πώς χρησιμοποιήθηκε το λεξικό:

>>> my_dict = {'a': 1, 'b': 2, 'c': 3}
>>> def getitem(name):
...      return my_dict[name]
...
>>> def setitem(name, val):
...     my_dict[name] = val
...
>>> mock = MagicMock()
>>> mock.__getitem__.side_effect = getitem
>>> mock.__setitem__.side_effect = setitem

Σημείωση

Μια εναλλακτική λύση στη χρήση του MagicMock είναι να χρησιμοποιήσετε το Mock και να παρέχετε μόνο τις μαγικές μεθόδους που θέλετε συγκεκριμένα:

>>> mock = Mock()
>>> mock.__getitem__ = Mock(side_effect=getitem)
>>> mock.__setitem__ = Mock(side_effect=setitem)

Μια τρίτη επιλογή είναι να χρησιμοποιήσετε το MagicMock αλλά περνώντας το dict ως όρισμα spec (ή spec_set), έτσι ώστε το δημιουργημένο MagicMock να έχει διαθέσιμες μόνο τις μαγικές μεθόδους λεξικού:

>>> mock = MagicMock(spec_set=dict)
>>> mock.__getitem__.side_effect = getitem
>>> mock.__setitem__.side_effect = setitem

Με αυτές τις λειτουργίες side effect στη θέση τους, το mock θα συμπεριφέρεται σαν ένα κανονικό λεξικό αλλά καταγράφοντας την πρόσβαση. Ακόμα κάνει raise μια KeyError εάν προσπαθήσετε να αποκτήσετε πρόσβαση σε ένα κλειδί που δεν υπάρχει.

>>> mock['a']
1
>>> mock['c']
3
>>> mock['d']
Traceback (most recent call last):
    ...
KeyError: 'd'
>>> mock['b'] = 'fish'
>>> mock['d'] = 'eggs'
>>> mock['b']
'fish'
>>> mock['d']
'eggs'

Μετά τη χρήση του, μπορείτε να κάνετε δηλώσεις σχετικά με την πρόσβαση χρησιμοποιώντας τις κανονικές μεθόδους και χαρακτηριστικά προσομοίωσης:

>>> mock.__getitem__.call_args_list
[call('a'), call('c'), call('d'), call('b'), call('d')]
>>> mock.__setitem__.call_args_list
[call('b', 'fish'), call('d', 'eggs')]
>>> my_dict
{'a': 1, 'b': 'fish', 'c': 3, 'd': 'eggs'}

Υποκλάσεις Mock και τα χαρακτηριστικά τους

Υπάρχουν διάφοροι λόγοι για τους οποίους μπορεί να θέλετε να υποκλάσετε την Mock. Ένας λόγος μπορεί να είναι η προσθήκη βοηθητικών μεθόδων. Εδώ είναι ένα ανόητο παράδειγμα:

>>> class MyMock(MagicMock):
...     def has_been_called(self):
...         return self.called
...
>>> mymock = MyMock(return_value=None)
>>> mymock
<MyMock id='...'>
>>> mymock.has_been_called()
False
>>> mymock()
>>> mymock.has_been_called()
True

Η τυπική συμπεριφορά για τα στιγμιότυπα Mock είναι ότι τα χαρακτηριστικά και οι επιστρεφόμενες τιμές προσομοιώσεων είναι του ίδιου τύπου με την προσομοίωση στην οποία έχουν πρόσβαση. Αυτό διασφαλίζει ότι τα χαρακτηριστικά Mock είναι Mocks και τα χαρακτηριστικά MagicMock είναι MagicMocks [2]. Έτσι, εάν υποκλάσετε για να προσθέσετε βοηθητικές μεθόδους, τότε θα είναι επίσης διαθέσιμες στα χαρακτηριστικά και στην επιστρεφόμενη τιμή προσομοίωσης των στιγμιότυπων της υποκλάσης σας.

>>> mymock.foo
<MyMock name='mock.foo' id='...'>
>>> mymock.foo.has_been_called()
False
>>> mymock.foo()
<MyMock name='mock.foo()' id='...'>
>>> mymock.foo.has_been_called()
True

Μερικές φορές αυτό είναι άβολο. Για παράδειγμα, ένας χρήστης υποκλάσει την προσομοίωση για να δημιουργήσει έναν προσαρμογέα Twisted. Η εφαρμογή αυτού και στα χαρακτηριστικά προκαλεί πραγματικά σφάλματα.

Mock (σε όλες τις παραλλαγές του) χρησιμοποιεί μια μέθοδο που ονομάζεται _get_child_mock για να δημιουργήσει αυτές τις «υπο-προσομοιώσεις» για χαρακτηριστικά και επιστρεφόμενες τιμές. Μπορείτε να αποτρέψετε τη χρήση της υποκλάσης σας για χαρακτηριστικά, υπερκαλύπτοντας αυτή τη μέθοδο. Η υπογραφή είναι ότι λαμβάνει αυθαίρετα ορίσματα λέξεων-κλειδιών (**kwargs) που στη συνέχεια περνιούνται στον κατασκευαστή προσομοιώσεων:

>>> class Subclass(MagicMock):
...     def _get_child_mock(self, /, **kwargs):
...         return MagicMock(**kwargs)
...
>>> mymock = Subclass()
>>> mymock.foo
<MagicMock name='mock.foo' id='...'>
>>> assert isinstance(mymock, Subclass)
>>> assert not isinstance(mymock.foo, Subclass)
>>> assert not isinstance(mymock(), Subclass)

[2]

Μια εξαίρεση σε αυτόν τον κανόνα είναι οι μη κλητές προσομοιώσεις. Τα χαρακτηριστικά χρησιμοποιούν την κλητή παραλλαγή επειδή διαφορετικά οι μη κλητές προσομοιώσεις δεν θα μπορούσαν να έχουν κλητές μεθόδους.

Προσομοίωση εισαγωγών με το patch.dict

Μια κατάσταση όπου η προσομοίωση μπορεί να είναι δύσκολη είναι όταν έχετε μια τοπική εισαγωγή μέσα σε μια συνάρτηση. Αυτές είναι πιο δύσκολες για προσομοίωση επειδή δεν χρησιμοποιούν ένα αντικείμενο από το χώρο ονομάτων του module που μπορούμε να επιδιορθώσουμε.

Γενικά, οι τοπικές εισαγωγές πρέπει να αποφεύγονται. Κάποιες φορές γίνονται για να αποτραπούν οι κυκλικές εξαρτήσεις, για τις οποίες υπάρχει συνήθως ένας πολύ καλύτερος τρόπος για να λυθεί το πρόβλημα (αναδιαμόρφωση του κώδικα) ή για να αποτραπούν τα «προκαταβολικά κόστη» καθυστερώντας την εισαγωγή. Αυτό μπορεί επίσης να λυθεί με καλύτερους τρόπους από μια άνευ όρων τοπική εισαγωγή (αποθηκεύστε το module ως χαρακτηριστικό κλάσης ή module και κάντε την εισαγωγή μόνο στην πρώτη χρήση).

Ανεξάρτητα από αυτό, υπάρχει ένας τρόπος να χρησιμοποιήσετε το mock για να επηρεάσετε τα αποτελέσματα μιας εισαγωγής. Η εισαγωγή ανακτά ένα αντικείμενο από το λεξικό sys.modules. Σημειώστε ότι ανακτά ένα αντικείμενο, το οποίο δεν χρειάζεται να είναι ένα module. Η εισαγωγή ενός module για πρώτη φορά έχει ως αποτέλεσμα τη τοποθέτηση ενός αντικειμένου module στο sys.modules, οπότε συνήθως όταν εισάγετε κάτι, λαμβάνετε πίσω ένα module. Ωστόσο, αυτό δεν χρειάζεται να είναι η περίπτωση.

Αυτό σημαίνει ότι μπορείτε να χρησιμοποιήσετε το patch.dict() για να τοποθετήσετε προσωρινά μια προσομοίωση στο sys.modules. Οποιεσδήποτε εισαγωγές ενώ αυτή η επιδιόρθωση είναι ενεργή θα ανακτούν την προσομοίωση. Όταν ολοκληρωθεί η επιδιόρθωση (η διακοσμημένη συνάρτηση εξέρχεται, το σώμα της δήλωσης with ολοκληρώνεται ή καλείται το patcher.stop()), τότε ό,τι υπήρχε προηγουμένως θα αποκατασταθεί με ασφάλεια.

Εδώ είναι ένα παράδειγμα που προσομοιώνει το module “fooble”.

>>> import sys
>>> mock = Mock()
>>> with patch.dict('sys.modules', {'fooble': mock}):
...    import fooble
...    fooble.blob()
...
<Mock name='mock.blob()' id='...'>
>>> assert 'fooble' not in sys.modules
>>> mock.blob.assert_called_once_with()

Όπως μπορείτε να δείτε, το import fooble πετυχαίνει, αλλά κατά την έξοδο δεν παραμένει κανένα “fooble” στο sys.modules.

Αυτό λειτουργεί επίσης για τη μορφή from module import name:

>>> mock = Mock()
>>> with patch.dict('sys.modules', {'fooble': mock}):
...    from fooble import blob
...    blob.blip()
...
<Mock name='mock.blob.blip()' id='...'>
>>> mock.blob.blip.assert_called_once_with()

Με λίγη περισσότερη δουλειά, μπορείτε επίσης να προσομοιώσετε εισαγωγές πακέτων:

>>> mock = Mock()
>>> modules = {'package': mock, 'package.module': mock.module}
>>> with patch.dict('sys.modules', modules):
...    from package.module import fooble
...    fooble()
...
<Mock name='mock.module.fooble()' id='...'>
>>> mock.module.fooble.assert_called_once_with()

Παρακολούθηση της σειράς κλήσεων και λιγότερο λεκτικές δηλώσεις κλήσεων

Η Mock σας επιτρέπει να παρακολουθείτε τη σειρά των κλήσεων μεθόδων στις προσομοιώσεις σας μέσω του χαρακτηριστικού method_calls. Αυτό δεν σας επιτρέπει να παρακολουθείτε τη σειρά των κλήσεων μεταξύ ξεχωριστών αντικειμένων προσομοίωσης, ωστόσο μπορούμε να χρησιμοποιήσουμε το mock_calls για να επιτύχουμε το ίδιο αποτέλεσμα.

Επειδή οι προσομοιώσεις παρακολουθούν τις κλήσεις σε υπο-προσομοιώσεις στο mock_calls, και η πρόσβαση σε ένα αυθαίρετο χαρακτηριστικό μιας προσομοίωσης δημιουργεί μια υπο-προσομοίωση, μπορούμε να δημιουργήσουμε τις ξεχωριστές προσομοιώσεις μας από μια γονική. Οι κλήσεις σε αυτές τις υπο-προσομοιώσεις θα καταγράφονται στη συνέχεια, με σειρά, στο mock_calls της γονικής:

>>> manager = Mock()
>>> mock_foo = manager.foo
>>> mock_bar = manager.bar

>>> mock_foo.something()
<Mock name='mock.foo.something()' id='...'>
>>> mock_bar.other.thing()
<Mock name='mock.bar.other.thing()' id='...'>

>>> manager.mock_calls
[call.foo.something(), call.bar.other.thing()]

Μπορούμε στη συνέχεια να κάνουμε δηλώσεις σχετικά με τις κλήσεις, συμπεριλαμβανομένης της σειράς, συγκρίνοντας με το χαρακτηριστικό mock_calls στην προσομοίωση διαχειριστή:

>>> expected_calls = [call.foo.something(), call.bar.other.thing()]
>>> manager.mock_calls == expected_calls
True

Αν το patch δημιουργεί και τοποθετεί τις προσομοιώσεις σας, τότε μπορείτε να τις επισυνάψετε σε μια διαχειριστική προσομοίωση χρησιμοποιώντας τη μέθοδο attach_mock(). Μετά την επισύναψη, οι κλήσεις θα καταγράφονται στο mock_calls του διαχειριστή.

>>> manager = MagicMock()
>>> with patch('mymodule.Class1') as MockClass1:
...     with patch('mymodule.Class2') as MockClass2:
...         manager.attach_mock(MockClass1, 'MockClass1')
...         manager.attach_mock(MockClass2, 'MockClass2')
...         MockClass1().foo()
...         MockClass2().bar()
<MagicMock name='mock.MockClass1().foo()' id='...'>
<MagicMock name='mock.MockClass2().bar()' id='...'>
>>> manager.mock_calls
[call.MockClass1(),
call.MockClass1().foo(),
call.MockClass2(),
call.MockClass2().bar()]

Εάν έχουν γίνει πολλές κλήσεις, αλλά σας ενδιαφέρει μόνο μια συγκεκριμένη ακολουθία από αυτές, τότε μια εναλλακτική είναι να χρησιμοποιήσετε τη μέθοδο assert_has_calls(). Αυτή λαμβάνει μια λίστα κλήσεων (κατασκευασμένη με το call αντικείμενο). Εάν αυτή η ακολουθία κλήσεων βρίσκεται στο mock_calls, τότε η δήλωση πετυχαίνει.

>>> m = MagicMock()
>>> m().foo().bar().baz()
<MagicMock name='mock().foo().bar().baz()' id='...'>
>>> m.one().two().three()
<MagicMock name='mock.one().two().three()' id='...'>
>>> calls = call.one().two().three().call_list()
>>> m.assert_has_calls(calls)

Ακόμα κι αν η αλυσιδωτή κλήση m.one().two().three() δεν είναι οι μόνες κλήσεις που έχουν γίνει στην προσομοίωση, η δήλωση εξακολουθεί να πετυχαίνει.

Μερικές φορές μια προσομοίωση μπορεί να έχει γίνει πολλές κλήσεις σε αυτήν, και σας ενδιαφέρει μόνο να κάνετε δηλώσεις για μερικές από αυτές τις κλήσεις. Μπορεί να μην σας ενδιαφέρει καν η σειρά. Σε αυτή την περίπτωση, μπορείτε να περάσετε το any_order=True στο assert_has_calls:

>>> m = MagicMock()
>>> m(1), m.two(2, 3), m.seven(7), m.fifty('50')
(...)
>>> calls = [call.fifty('50'), call(1), call.seven(7)]
>>> m.assert_has_calls(calls, any_order=True)

Πιο σύνθετη αντιστοίχιση ορισμάτων

Χρησιμοποιώντας την ίδια βασική έννοια με το ANY, μπορούμε να υλοποιήσουμε αντιστοιχίσεις για να κάνουμε πιο σύνθετες δηλώσεις σχετικά με αντικείμενα που χρησιμοποιούνται ως ορίσματα σε προσομοιώσεις.

Ας υποθέσουμε ότι αναμένουμε να περαστεί κάποιο αντικείμενο σε μια προσομοίωση που κανονικά συγκρίνεται ως ίσο βάσει της ταυτότητας του αντικειμένου (που είναι το προεπιλεγμένο της Python για καθορισμένες από τον χρήστη κλάσεις). Για να χρησιμοποιήσουμε τη assert_called_with(), θα πρέπει να περάσουμε το ακριβώς ίδιο αντικείμενο. Εάν μας ενδιαφέρουν μόνο μερικά από τα χαρακτηριστικά αυτού του αντικειμένου, τότε μπορούμε να δημιουργήσουμε έναν αντιστοιχιστή που θα ελέγχει αυτά τα χαρακτηριστικά για εμάς.

Μπορείτε να δείτε σε αυτό το παράδειγμα πώς μια “τυπική” κλήση στο assert_called_with δεν είναι επαρκής:

>>> class Foo:
...     def __init__(self, a, b):
...         self.a, self.b = a, b
...
>>> mock = Mock(return_value=None)
>>> mock(Foo(1, 2))
>>> mock.assert_called_with(Foo(1, 2))
Traceback (most recent call last):
    ...
AssertionError: expected call not found.
Expected: mock(<__main__.Foo object at 0x...>)
Actual: mock(<__main__.Foo object at 0x...>)

Μια συνάρτηση σύγκρισης για την κλάση μας Foo μπορεί να μοιάζει κάπως έτσι:

>>> def compare(self, other):
...     if not type(self) == type(other):
...         return False
...     if self.a != other.a:
...         return False
...     if self.b != other.b:
...         return False
...     return True
...

Και ένα αντικείμενο αντιστοίχισης που μπορεί να χρησιμοποιεί συναρτήσεις σύγκρισης όπως αυτή για τη λειτουργία ισότητας του θα μοιάζει κάπως έτσι:

>>> class Matcher:
...     def __init__(self, compare, some_obj):
...         self.compare = compare
...         self.some_obj = some_obj
...     def __eq__(self, other):
...         return self.compare(self.some_obj, other)
...

Βάζοντας όλα αυτά μαζί:

>>> match_foo = Matcher(compare, Foo(1, 2))
>>> mock.assert_called_with(match_foo)

Το Matcher δημιουργείται με τη συνάρτηση σύγκρισης και το αντικείμενο που θέλουμε να συγκρίνουμε. Στο assert_called_with, θα κληθεί η μέθοδος ισότητας του Matcher, η οποία συγκρίνει το αντικείμενο με το οποίο κλήθηκε η προσομοίωση με αυτό που δημιουργήσαμε τον αντιστοιχιστή μας. Εάν ταιριάζουν, τότε το assert_called_with περνάει, και αν δεν ταιριάζουν, γίνεται raise μια AssertionError:

>>> match_wrong = Matcher(compare, Foo(3, 4))
>>> mock.assert_called_with(match_wrong)
Traceback (most recent call last):
    ...
AssertionError: Expected: ((<Matcher object at 0x...>,), {})
Called with: ((<Foo object at 0x...>,), {})

Με λίγη τροποποίηση, θα μπορούσατε να κάνετε τη συνάρτηση σύγκρισης να κάνει raise απευθείας την AssertionError και να παρέχει ένα πιο χρήσιμο μήνυμα αποτυχίας.

Από την έκδοση 1.5, η βιβλιοθήκη δοκιμών Python PyHamcrest παρέχει παρόμοια λειτουργικότητα, που μπορεί να είναι χρήσιμη εδώ, με τη μορφή του αντιστοιχιστή ισότητας (hamcrest.library.integration.match_equality).