Python: Prototipo de un módulo sin importarlo o que necesitan que exista

Question

estoy usando empezando a utilizar una pitón mock library para mi prueba. Quiero simular un módulo que se importa dentro del espacio de nombres del módulo bajo prueba sin realmente importarlo o exigir que exista primero (es decir, lanzar un ImportError).

Supongamos que existe el siguiente código:

foo.py

import helpers 
def foo_func(): 
    return helpers.helper_func() 

El objetivo es poner a prueba foo_func() cuando 'helpers.py' no existe en ninguna parte, y si existe, acto como si no fuera así

primer intento, mediante el super cool decorador @patch:

from mock import patch, sentinel 
import foo 
@patch("foo.helpers") 
def foo_test(mock): 
    mock.helper_func.return_value = sentinel.foobar 
    assert foo.foo_func() == sentinel.foobar 

Esto funciona si el módulo de "ayudantes" se puede importar. Si no existe, obtengo un ImportError.

siguiente intento con el parche, sans decorador:

from mock import patch, sentinel, Mock 
import foo 
helpers_mock = patch("foo.helpers") 
helpers_mock.start() 

def foo_test(): 
    helpers_mock.helper_func = Mock('helper_func') 
    helpers_mock.helper_func.return_value = sentinel.foobar 
    assert foo.foo_func() == sentinel.foobar 

Una vez más, esto no funciona si "ayudantes" que falta ... y, si existe, la afirmación falla. No estoy muy seguro de por qué sucede eso.

tercer intento, solución actual:

import sys 
helpers_mock = Mock(name="helpers_mock", spec=['helper_func']) 
helpers_mock.__name__ = 'helpers' 
sys.modules['helpers'] = helpers_mock 
import foo 
def foo_test(): 
    helpers_mock.helper_func.return_value = sentinel.foobar 
    assert foo.foo_func() == sentinel.foobar 

pasa esta prueba, independientemente de si existe o no "helpers.py".

¿Es esta la mejor manera de lograr este objetivo? ¿La biblioteca burlona que estoy usando ofrece una alternativa a esto? ¿De qué otra manera puedo hacer esto?

Answer 1

que estés tipo de falta el punto de lo que una Falsa. Se supone que debes construirlos cuando quieras un objeto con una interfaz particular, independientemente de cómo se implemente.

Lo que está haciendo es tratar de volver a implementar sistema de módulos de Python, y además es un abuso bastante horrible de variables globales para arrancar.

En lugar de hacer un módulo foo, crea una clase Foo, y pasan en los ayudantes en el constructor.

class Foo(object): 
    def __init__(self, helpers): 
     self.helpers = helpers 

# then, instead of import foo: 
foo = Foo(mock_helpers) 

Incluso si los verdaderos "ayudantes" es en realidad va a ser un módulo, no hay ninguna razón por la que necesita estar jugando con sys.modules y su puesta en marcha a través de import en sus pruebas.

Y si foo tiene que ser un módulo, que también está bien, pero hacerlo de esta manera:

# foo.py 
class Foo(object): 
    pass # same code as before, plus foo_func 

try: 
    import whatever 
    _singleton = Foo(whatever) 
except ImportError: 
    _singleton = Foo(something_else) 

def foo_func(): 
    return _singleton.foo_func() 

grandes trozos del trabajo de la biblioteca estándar de esta manera. Es prácticamente el estándar para definir módulos tipo singleton.