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"