In Python, c'è un buon idioma per usare i gestori di contesto in setup/teardown

Question

Sto scoprendo che sto usando molti gestori di contesto in Python. Tuttavia, Ho testato una serie di cose che li utilizzano, e spesso mi viene la necessità della seguente:

class MyTestCase(unittest.TestCase): 
    def testFirstThing(self): 
    with GetResource() as resource: 
     u = UnderTest(resource) 
     u.doStuff() 
     self.assertEqual(u.getSomething(), 'a value') 

    def testSecondThing(self): 
    with GetResource() as resource: 
     u = UnderTest(resource) 
     u.doOtherStuff() 
     self.assertEqual(u.getSomething(), 'a value') 

Quando questo arriva a molte prove, questo è chiaramente sta per diventare noioso, così nello spirito di SPOT/ASCIUTTO (singolo punto di verità/non ripetersi), vorrei refactoring quei bit nei metodi di prova setUp() e tearDown().

Tuttavia, cercando di fare che ha portato a questa bruttezza:

def setUp(self): 
    self._resource = GetSlot() 
    self._resource.__enter__() 

    def tearDown(self): 
    self._resource.__exit__(None, None, None) 

Ci deve essere un modo migliore per fare questo. Idealmente, nel setUp()/tearDown() senza bit ripetitivi per ogni metodo di prova (posso vedere come la ripetizione di un decoratore su ciascun metodo potrebbe farlo).

Modifica: Considerare l'oggetto undertest come interno e l'oggetto GetResource come una terza parte (cosa che non stiamo cambiando).

Ho rinominato GetSlot in GetResource qui-questo è più generale del caso specifico, in cui i gestori di contesto sono il modo in cui l'oggetto è destinato a entrare in uno stato bloccato e fuori.

Answer 1

Che ne dici di sostituire unittest.TestCase.run() come illustrato di seguito? Questo approccio non richiede di chiamare metodi privati ​​o di fare qualcosa per ogni metodo, che è ciò che l'interrogante voleva.

from contextlib import contextmanager 
import unittest 

@contextmanager 
def resource_manager(): 
    yield 'foo' 

class MyTest(unittest.TestCase): 

    def run(self, result=None): 
     with resource_manager() as resource: 
      self.resource = resource 
      super(MyTest, self).run(result) 

    def test(self): 
     self.assertEqual('foo', self.resource) 

unittest.main() 

Questo approccio permette anche passando l'istanza TestCase al contesto manager, se si desidera modificare l'istanza TestCase lì.

Answer 2

Il problema con il chiamare __enter__ e __exit__ come hai fatto, non è che lo hai fatto: possono essere chiamati al di fuori di una dichiarazione with. Il problema è che il tuo codice non prevede di chiamare correttamente il metodo __exit__ dell'oggetto se si verifica un'eccezione.

Quindi, il modo per farlo è avere un decoratore che avvolgerà la chiamata al metodo originale in una istruzione with. Una breve metaclasse può applicare il decoratore in modo trasparente a tutti i metodi di nome test * nella classe -

# -*- coding: utf-8 -*- 

from functools import wraps 

import unittest 

def setup_context(method): 
    # the 'wraps' decorator preserves the original function name 
    # otherwise unittest would not call it, as its name 
    # would not start with 'test' 
    @wraps(method) 
    def test_wrapper(self, *args, **kw): 
     with GetSlot() as slot: 
      self._slot = slot 
      result = method(self, *args, **kw) 
      delattr(self, "_slot") 
     return result 
    return test_wrapper 

class MetaContext(type): 
    def __new__(mcs, name, bases, dct): 
     for key, value in dct.items(): 
      if key.startswith("test"): 
       dct[key] = setup_context(value) 
     return type.__new__(mcs, name, bases, dct) 


class GetSlot(object): 
    def __enter__(self): 
     return self 
    def __exit__(self, *args, **kw): 
     print "exiting object" 
    def doStuff(self): 
     print "doing stuff" 
    def doOtherStuff(self): 
     raise ValueError 

    def getSomething(self): 
     return "a value" 

def UnderTest(*args): 
    return args[0] 

class MyTestCase(unittest.TestCase): 
    __metaclass__ = MetaContext 

    def testFirstThing(self): 
     u = UnderTest(self._slot) 
     u.doStuff() 
     self.assertEqual(u.getSomething(), 'a value') 

    def testSecondThing(self): 
     u = UnderTest(self._slot) 
     u.doOtherStuff() 
     self.assertEqual(u.getSomething(), 'a value') 

unittest.main() 

(ho incluso anche implementazioni finte di "GetSlot" ei metodi e le funzioni nel vostro esempio in modo che io stesso potrei testare la decoratore e metaclasse suggerisco in questa risposta)

Answer 3

Direi che dovresti separare il test del gestore di contesto dal test della classe Slot. Si potrebbe anche usare un oggetto fittizio simulando l'interfaccia di inizializzazione/finalizzazione dello slot per testare l'oggetto gestore di contesto e quindi testare separatamente l'oggetto slot.

from unittest import TestCase, main 

class MockSlot(object): 
    initialized = False 
    ok_called = False 
    error_called = False 

    def initialize(self): 
     self.initialized = True 

    def finalize_ok(self): 
     self.ok_called = True 

    def finalize_error(self): 
     self.error_called = True 

class GetSlot(object): 
    def __init__(self, slot_factory=MockSlot): 
     self.slot_factory = slot_factory 

    def __enter__(self): 
     s = self.s = self.slot_factory() 
     s.initialize() 
     return s 

    def __exit__(self, type, value, traceback): 
     if type is None: 
      self.s.finalize_ok() 
     else: 
      self.s.finalize_error() 


class TestContextManager(TestCase): 
    def test_getslot_calls_initialize(self): 
     g = GetSlot() 
     with g as slot: 
      pass 
     self.assertTrue(g.s.initialized) 

    def test_getslot_calls_finalize_ok_if_operation_successful(self): 
     g = GetSlot() 
     with g as slot: 
      pass 
     self.assertTrue(g.s.ok_called) 

    def test_getslot_calls_finalize_error_if_operation_unsuccessful(self): 
     g = GetSlot() 
     try: 
      with g as slot: 
       raise ValueError 
     except: 
      pass 

     self.assertTrue(g.s.error_called) 

if __name__ == "__main__": 
    main() 

Questo rende più semplice codice, impedisce preoccupazione miscelazione e consente di riutilizzare il manager contesto senza dover codificare in molti luoghi.

Answer 4

Manipolare i gestori di contesto in situazioni in cui non si desidera un'istruzione with per pulire le cose se tutte le acquisizioni di risorse sono riuscite è uno dei casi d'uso che è stato progettato per gestire contextlib.ExitStack().

Per esempio (usando addCleanup() invece di un'implementazione personalizzata tearDown()):

def setUp(self): 
    with contextlib.ExitStack() as stack: 
     self._resource = stack.enter_context(GetResource()) 
     self.addCleanup(stack.pop_all().close) 

Questo è l'approccio più robusto, dal momento che gestisce correttamente l'acquisizione di molteplici risorse:

def setUp(self): 
    with contextlib.ExitStack() as stack: 
     self._resource1 = stack.enter_context(GetResource()) 
     self._resource2 = stack.enter_context(GetOtherResource()) 
     self.addCleanup(stack.pop_all().close) 

Qui, se GetOtherResource() fallisce, la prima risorsa verrà ripulita immediatamente dall'istruzione with, mentre se riesce, la chiamata pop_all() rimanderà la pulizia fino alla pulitura registrata f corse di unction.

Se sai che stai sempre e solo andando ad avere una risorsa da gestire, è possibile saltare l'istruzione with:

def setUp(self): 
    stack = contextlib.ExitStack() 
    self._resource = stack.enter_context(GetResource()) 
    self.addCleanup(stack.close) 

Tuttavia, questo è un altro errore di bit prona, dal momento che se si aggiungono più risorse per lo stack senza prima passare alla versione basata sull'istruzione, le risorse allocate correttamente potrebbero non essere prontamente ripulite se le successive acquisizioni di risorse falliscono.

Si può anche scrivere qualcosa di paragonabile con un tearDown() un'implementazione personalizzata salvando un riferimento alla pila risorsa sul banco di prova:

def setUp(self): 
    with contextlib.ExitStack() as stack: 
     self._resource1 = stack.enter_context(GetResource()) 
     self._resource2 = stack.enter_context(GetOtherResource()) 
     self._resource_stack = stack.pop_all() 

def tearDown(self): 
    self._resource_stack.close() 

Answer 5

pytest infissi sono molto vicini alla tua idea/stile, e consentire esattamente quello che vuoi:

import pytest 
from code.to.test import foo 

@pytest.fixture(...) 
def resource(): 
    with your_context_manager as r: 
     yield r 

def test_foo(resource): 
    assert foo(resource).bar() == 42