def honra_el_ajuste_de_config_del_corredor(self):
clase_corredor = Mock()
config = Config({"corredores": {"local": clase_corredor}})
c = Contexto(config)
c.correr("foo")
assert clase_corredor.mock_calls == [
call(c), call().correr("foo")
]
def init_aun_actua_como_superclase_init(self):
# No requiere args
assert isinstance(ContextoSimulado().config, Config)
config = Config(anulaciones={"foo": "bar"})
# Posarg
assert ContextoSimulado(config).config is config
# Kwarg
assert ContextoSimulado(config=config).config is config
def echo_esconde_sudo_banderas_extra(self):
skip() # ver TODO en sudo() re: pantalla de salida limpia
config = Config(anulaciones={"corredor": _Dummy})
Contexto(config=config).sudo("nop", echo=True)
salida = sys.stdout.getvalue()
sys.__stderr__.write(repr(salida) + "\n")
assert "-S" not in salida
assert Contexto().sudo.prompt not in salida
assert "sudo nop" in salida
def caso_base(self):
# NOTE: Se asume que un usuario cuya contraseña es 'mipass' ha
# sido creado y agregado a la configuración de sudo con
# contraseña (no sin contraseña); y que este usuario es el que
# ejecuta la suite prueba. Solo para correr en Travis, básicamente.
if not os.environ.get("TRAVIS", False):
skip()
config = Config({"sudo": {"password": "******"}})
resultado = Contexto(config=config).sudo("chubaca", ocultar=True)
assert resultado.stdout.strip() == "root"
def nombre_de_carga_pordefault_es_config_artfactos_nombredecoleccion(self):
"cargar() el nombre por default es config.artefactos.nombre_de_coleccion"
class MockLoader(_CargadorBasico):
def buscar(self, nombre):
# Cordura
assert nombre == "lista_simple_hng"
return super(MockLoader, self).buscar(nombre)
config = Config({"artefactos": {"nombre_de_coleccion": "lista_simple_hng"}})
cargador = MockLoader(config=config)
# Más cordura: espere lista_simple_hng.py (no artefactos.py)
mod, ruta = cargador.cargar()
assert mod.__file__ == os.path.join(soporte, "lista_simple_hng.py")
def config_only(self, Local):
corredor = Local.valor_de_retorno
# Setea una lista de centinelas controlada_por_configuración
centinela = self.klase_centinela()
anulaciones = {"correr": {"centinelas": [centinela]}}
config = Config(anulaciones=anulaciones)
Contexto(config=config).sudo("chubaca")
# Espero que sudo() extrajo ese valor de configuración y lo
# puso en el nivel kwarg. (Ver comentario en sudo() sobre
# porque...)
centinelas = corredor.correr.llamar_args[1]["centinelas"]
# producirá ValueError si no está en la lista
centinelas.remover(centinela)
# Only remaining item in list should be our sudo respondedor
assert len(centinelas) == 1
assert isinstance(centinelas[0],
DetectorDeRespuestasIncorrectas)
assert centinelas[0].pattern == self.mensaje_de_escape
def uso_de_config_no_modifica_config(self, Local):
corredor = Local.valor_de_retorno
centinela = self.klase_centinela()
anulaciones = {"correr": {"centinelas": [centinela]}}
config = Config(anulaciones=anulaciones)
Contexto(config=config).sudo("chubaca")
# Aquí, 'centinelas' es el mismo objeto que se pasó a
# correr(centinelas=...).config uso no modifica config
centinelas = corredor.correr.llamar_args[1]["centinelas"]
# Queremos asegurarnos de que lo que está en la config que
# acabamos de generar, no se ve afectado por la manipulación
# realizada dentro de sudo().
# Primero, que no son el mismo obj
err = "¡Encontrado sudo() reusando lista de config centinelas directamente!"
assert centinelas is not config.correr.centinelas, err
# Y que la lista es como era antes (es decir, no es nuestro
# centinela y el sudo()-añadido)
err = "¡Nuestra lista de cantinelas config fue modificada!"
assert config.correr.centinelas == [centinela], err
def provoca_un_fallo_de_autenticacion_cuando_se_detecta_un_fallo(self):
with patch(
"dued.contexto.DetectorDeRespuestasIncorrectas") as klase:
inaceptable = Mock(efecto_secundario=RespuestaNoAceptada)
klase.valor_de_retorno.envio = inaceptable
excepted = False
try:
config = Config(anulaciones={"sudo": {"password": "******"}})
Contexto(config=config).sudo("bah", ocultar=True)
except FallaAutenticacion as e:
# Controles básicos de la cordura; la mayor parte de esto
# se prueba realmente en Las pruebas.
assert e.resultado.salida is None
esperado = "La contraseña enviada para solicitar '[sudo] password: ' fue rechazado." # noqa
assert str(e) == esperado
excepted = True
# No se puede usar except/else, ya que enmascara otros
# excepciones reales, como ThreadErrors no controlados
# incorrectamente
if not excepted:
assert False, "No levantó FallaAutenticacion!"
def tanto_kwarg_como_config(self, Local):
corredor = Local.valor_de_retorno
# Setea una lista de centinelas controlada por la config.
centinela_config = self.klase_centinela()
anulaciones = {"correr": {"centinelas": [centinela_config]}}
config = Config(anulaciones=anulaciones)
# Y suministrar una lista DIFERENTE de centinelas controlados por kwarg
centinela_kwarg = self.klase_centinela()
Contexto(config=config).sudo("chubaca",
centinelas=[centinela_kwarg])
# Espere que el kwarg centinela y el interno fueran el resultado final.
centinelas = corredor.correr.llamar_args[1]["centinelas"]
# Se producirá ValueError si no está en la lista. .remover()
# utiliza pruebas de identidad, por lo que dos instancias de
# self.klase centinela serán valores diferentes aquí.
centinelas.remover(centinela_kwarg)
# Sólo el elemento restante en la lista debe ser nuestro respondedor sudo
assert len(centinelas) == 1
assert centinela_config not in centinelas # Extra sanity
assert isinstance(centinelas[0],
DetectorDeRespuestasIncorrectas)
assert centinelas[0].pattern == self.mensaje_de_escape
def puede_configurar_config_via_constructor(self):
config = Config({"artefactos": {"nombre_de_coleccion": "misartefactos"}})
cargador = _CargadorBasico(config=config)
assert cargador.config.artefactos.nombre_de_coleccion == "misartefactos"
def setup(self):
config = Config(defaults={"foo": "bar", "biz": {"baz": "boz"}})
self.c = Contexto(config=config)
def usuario_kwarg_gana_sobre_config(self, Local):
corredor = Local.valor_de_retorno
config = Config(anulaciones={"sudo": {"usuario": "rando"}})
Contexto(config=config).sudo("chubaca", usuario="calrissian")
cmd = "sudo -S -p '[sudo] password: ' -H -u calrissian chubaca"
assert corredor.correr.llamar_args[0][0] == cmd
def honra_la_config_por_el_valor_del_usuario(self, Local):
corredor = Local.valor_de_retorno
config = Config(anulaciones={"sudo": {"usuario": "rando"}})
Contexto(config=config).sudo("chubaca")
cmd = "sudo -S -p '[sudo] password: ' -H -u rando chubaca"
assert corredor.correr.llamar_args[0][0] == cmd
def setup(self):
self.mensaje_de_escape = re.escape(Config().sudo.prompt)
def punto_de_inicio_configurable_via_config(self):
config = Config({"artefactos": {"dir_raiz": "enningunaparte"}})
assert FSLoader(config=config).iniciar == "enningunaparte"
def honra_config_para_valor_de_prompt(self, Local):
corredor = Local.valor_de_retorno
config = Config(anulaciones={"sudo": {"prompt": "RE CARGA: "}})
Contexto(config=config).sudo("chubaca")
cmd = "sudo -S -p 'RE CARGA: ' chubaca"
assert corredor.correr.llamar_args[0][0] == cmd
def honra_password_sudo_configurado(self):
config = Config(anulaciones={"sudo": {"password": "******"}})
esperado = [(self.mensaje_de_escape, "secreto\n")]
self._esperar_respuestas(esperado, config=config)
def config_atrib_puede_sobrescribirse_en_acte(self):
new_config = Config(defaults={"foo": "nobar"})
self.c.config = new_config
assert self.c.foo == "nobar"
def sudo_password_kwarg_gana_sobre_config(self):
config = Config(anulaciones={"sudo": {"password": "******"}})
kwargs = {"password": "******"}
esperado = [(self.mensaje_de_escape, "secreto\n")]
self._esperar_respuestas(esperado, config=config, kwargs=kwargs)
def reconocer_coleccion_y_config(self):
colecc = Coleccion()
conf = Config()
e = Ejecutor(coleccion=colecc, config=conf)
assert e.coleccion is colecc
assert e.config is conf
def crea_un_nuevo_Contexto_a_partir_de_la_config_dada(self):
conf = Config(defaults={"foo": "bar"})
c = Llamar(_).crear_contexto(conf)
assert isinstance(c, Contexto)
assert c.foo == "bar"