Sie verspotten die super-Klasse fordert python

Ich bin dabei einige unit-Tests und irgendwann muss ich simulieren Sie eine super Aufruf einen Fehler auslösen, zum Beispiel:

@classmethod
def myfunc(cls, *args, **kwargs)
    try:
        super(MyClass, cls).my_function(args, kwargs)
    except MyException as e:
        #...

Ich bin mit dem mocker Bibliothek zu verspotten, meine Objekte im Allgemeinen, aber ich habe nicht gefunden eine Weise zu verspotten dies.

InformationsquelleAutor Hassek | 2012-10-26

32

Mit der mock Bibliothek würde ich so etwas tun.

In Ihrer Klasse definition:
```
from somelib import ASuperClass

class MyClass(ASuperClass):
    def my_cool_method(self):
        return super(MyClass, self).my_cool_method()
```
In dem Modul, in dem Sie anrufen MyClass:
```
from mock import patch
from mymodule import MyClass

@patch("mypackage.mymodule.ASuperClass.my_cool_method")
def call_with_mock(mocked_super):
    myinstance = MyClass()
    myinstance.my_cool_method()
    # do stuff with `mocked_super`

call_with_mock()
```
Update: Wie Python 3.3 die mock-Bibliothek ist Teil der standard-Bibliothek unter unittest.mock.
- Ich habe das problem mit diesem ist, dass ich ein viel my_cool_methods zu verspotten, und es ist unhandlich. Ich brauche einen Weg, um einfach nur zu verspotten, die ganze Klasse und nicht einzelne Methoden.
- Sie können spotten die gesamte Klasse.
- kann sicher nicht. Mocking einer Oberklasse macht Ihre Klasse eine Unterklasse einer mock, z.B. es wird ein Schein, und es verliert alle Methoden, die Sie testen möchten. Ich landete eine Klasse, nimmt eine andere Klasse als Eingabe, erstellt alle matching-Methoden auf sich selbst, wie mocks (so ist es ein echt Klasse enthält verspottet Methoden entsprechen den Methoden der anderen Klasse). dann habe ich überschreiben der von der Basisklasse der Klasse, die ich versuche zu testen, und ich bin in der Lage, um meine Methoden und bestätigen, dass die richtigen Oberklasse-Methoden aufgerufen, mit den richtigen Argumenten werden -- und heben Ausnahmen, wenn nötig.
- Sicher können. Siehe voidspace.org.uk/python/mock/mock.html#mock.Mock.method_calls und voidspace.org.uk/python/mock/mock.html#mock.Mock.mock_calls
- Nein, der link ist nicht im Zusammenhang zu dem, was ich bin reden über. Wenn ich eine class A: und ein class B(A): - und ich will testen B während der Spott der geerbten Methoden aus A können Sie nicht nur Modell A, weil B erbt von A - und so wird selbst zu einem mock, die verhindert, dass mir bei Aufruf der Methoden, die ich aufrufen möchten, denn werden Sie verspottet. Dies war für meinen use-case-statt: bazaar.launchpad.net/~cupstream2distro-Betreuer/...
- Es scheint, Sie können nicht erhalten Sie das beste aus beiden Welten. Wenn Sie wollen, zu verspotten, alle Methoden in der Oberklasse, ohne die Verspottung der Unterklasse, müssen Sie nur verspotten die Methoden 1 von 1
InformationsquelleAutor antonagestam

Habe ich einen Weg gefunden, eine Art hacky, aber es funktioniert, erkläre ich Ihnen mit meinem Beispiel, das basiert auf diese Antwort also danke @kindall:

def my_test(self):
    import __builtin__
    from mocker import Mocker, KWARGS, ARGS

    mymocker = mocker.mock()
    mymocker.my_function(ARGS, KWARGS)
    mocker.throw(MyException)

    def mysuper(*args, **kwargs):
        if args and issubclass(MyClass, args[0]):
            return mymocker
        return original_super(*args, **kwargs)

    __builtin__.original_super = super
    __builtin__.super = mysuper

    with mocker:
        MyClass.myfunc()

also im Grunde das, was ich Tue, ist zu prüfen, ob die super Anruf aus der Klasse ich will spotten, sonst nur eine normale super.

Hoffe, das jemand hilft 🙂

InformationsquelleAutor Hassek

0

Gut, dann müssen Sie verhöhnen die my_function Methode der Oberklasse MyClass zu sprengen.
- Ich weiß, ich kann mock dort etwas in die Luft zu sprengen, ich bin nur neugierig, wie mock das super Klasse aufrufen, sollte dies möglich sein. Danke für die Idee du.
- Du meinst, zu verspotten, die super callable selbst? Ich denke, das wird verursachen zu erhöhen, Ausnahmen auf mehr Plätze, als Ihnen lieb ist.
- ja, ich weiß, ist nicht etwas trivial :s
- Vielen Dank, diese Lösung funktioniert
InformationsquelleAutor Markus Unterwaditzer
0

@Markus ist auf der Suche an der richtigen Stelle. So lange, wie Sie unit-Tests (D. H. es gibt nur einen Anruf zu super), können Sie mock __builtin__.super wie in:
```
with mock.patch('__builtin__.super') as mock_super:
    mock_super.side_effect = TypeError
    with self.assertRaises(TypeError):
        obj.call_with_super()
```
InformationsquelleAutor claytond

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.