def genera_ValueError_si_coleccion_sin_nombre(self): # Las colecciones no-root deben tener un nombre explícito dado a # través de kwarg, tener un atributo de nombre establecido o ser # un módulo con __name__ definido. raiz = Coleccion() sub = Coleccion() with raises(ValueError): raiz.ad_coleccion(sub)
class ad_coleccion: def setup(self): self.c = Coleccion() def agrega_coleccion_como_subcoleccion_de_self(self): c2 = Coleccion("foo") self.c.ad_coleccion(c2) assert "foo" in self.c.colecciones def puede_tomar_objetos_modulo(self): self.c.ad_coleccion(load("integracion")) assert "integracion" in self.c.colecciones def genera_ValueError_si_coleccion_sin_nombre(self): # Las colecciones no-root deben tener un nombre explícito dado a # través de kwarg, tener un atributo de nombre establecido o ser # un módulo con __name__ definido. raiz = Coleccion() sub = Coleccion() with raises(ValueError): raiz.ad_coleccion(sub) def genera_ValueError_si_la_coleccion_tiene_el_mismo_nombre_que_el_artefacto( self): self.c.ad_artefacto(_miartefacto, "sub") with raises(ValueError): self.c.ad_coleccion(Coleccion("sub"))
class getitem: "__getitem__" def setup(self): self.c = Coleccion() def encuentra_sus_propios_artefactos_por_nombre(self): # TODO: duplica una prueba ad_artefacto anterior, ¿arreglar? self.c.ad_artefacto(_miartefacto, "foo") assert self.c["foo"] == _miartefacto def busca_artefactos_de_subcoleccion_por_nombre_con_puntos(self): sub = Coleccion("sub") sub.ad_artefacto(_miartefacto) self.c.ad_coleccion(sub) assert self.c["sub._miartefacto"] == _miartefacto def honra_alias_en_sus_propios_artefactos(self): t = Artefacto(_func, alias=["bar"]) self.c.ad_artefacto(t, "foo") assert self.c["bar"] == t def honra_los_alias_de_artefactos_de_subcoleccion(self): self.c.ad_coleccion(load("decoradores")) assert "decoradores.bar" in self.c def respeta_el_propio_artefacto_pordefault_sin_argumentos(self): t = Artefacto(_func, default=True) self.c.ad_artefacto(t) assert self.c[""] == t def respeta_los_artefactos_pordefecto_de_la_subcoleccion_en_el_nombre_de_la_subcoleccion( self): sub = Coleccion.del_modulo(load("decoradores")) self.c.ad_coleccion(sub) # Sanity assert self.c["decoradores.biz"] is sub["biz"] # Real prueba assert self.c["decoradores"] is self.c["decoradores.biz"] def genera_ValueError_sin_nombre_y_sin_valor_pordefecto(self): with raises(ValueError): self.c[""] def ValueError_para_el_nombre_de_artefacto_subcol_sin_valor_predeterminado( self): self.c.ad_coleccion(Coleccion("cualquier")) with raises(ValueError): self.c["cualquier"]
class configuracion: "metodos de configuración" def setup(self): self.raiz = Coleccion() self.artefacto = Artefacto(_func, nombre="artefacto") def seteo_y_obtencion_basico(self): self.raiz.configurar({"foo": "bar"}) assert self.raiz.configuracion() == {"foo": "bar"} def configurar_realiza_la_fusion(self): self.raiz.configurar({"foo": "bar"}) assert self.raiz.configuracion()["foo"] == "bar" self.raiz.configurar({"biz": "baz"}) assert set(self.raiz.configuracion().keys()), {"foo" == "biz"} def configurar_la_combinacion_es_recursivo_para_dic_anidados(self): self.raiz.configurar({"foo": "bar", "biz": {"baz": "boz"}}) self.raiz.configurar({"biz": {"otrobaz": "otroboz"}}) c = self.raiz.configuracion() assert c["biz"]["baz"] == "boz" assert c["biz"]["otrobaz"] == "otroboz" def configurar_permite_sobrescribir(self): self.raiz.configurar({"foo": "one"}) assert self.raiz.configuracion()["foo"] == "one" self.raiz.configurar({"foo": "two"}) assert self.raiz.configuracion()["foo"] == "two" def devuelve_llamada_dic(self): assert self.raiz.configuracion() == {} self.raiz.configurar({"foo": "bar"}) assert self.raiz.configuracion() == {"foo": "bar"} def acceso_fusiona_desde_subcolecciones(self): interior = Coleccion("interior", self.artefacto) interior.configurar({"foo": "bar"}) self.raiz.configurar({"biz": "baz"}) # With no interior coleccion assert set(self.raiz.configuracion().keys()) == {"biz"} # With interior coleccion self.raiz.ad_coleccion(interior) claves = set(self.raiz.configuracion("interior.artefacto").keys()) assert claves == {"foo", "biz"} def padres_sobrescriben_a_hijos_en_el_camino(self): interior = Coleccion("interior", self.artefacto) interior.configurar({"foo": "interior"}) self.raiz.ad_coleccion(interior) # Antes de actualizar la configuración coleccion raiz, refleja el int assert self.raiz.configuracion( "interior.artefacto")["foo"] == "interior" self.raiz.configurar({"foo": "exterior"}) # Después, refleja el exterior (ya que ahora anulaciones) assert self.raiz.configuracion( "interior.artefacto")["foo"] == "exterior" def subcolecciones_hermanos_ignoradas(self): interior = Coleccion("interior", self.artefacto) interior.configurar({"foo": "hola"}) interios2 = Coleccion("interios2", Artefacto(_func, nombre="artefacto2")) interios2.configurar({"foo": "nop"}) raiz = Coleccion(interior, interios2) assert raiz.configuracion("interior.artefacto")["foo"] == "hola" assert raiz.configuracion("interios2.artefacto2")["foo"] == "nop" def rutas_de_subcolecciones_pueden_tener_puntos(self): hoja = Coleccion("hoja", self.artefacto) hoja.configurar({"clave": "hoja-valor"}) medio = Coleccion("medio", hoja) raiz = Coleccion("raiz", medio) config = raiz.configuracion("medio.hoja.artefacto") assert config == {"clave": "hoja-valor"} def Lrutas_de_subcoleccion_no_válidas_resultan_en_KeyError(self): # Directamente no válido with raises(KeyError): Coleccion("bah").configuracion("nop.artefacto") # Existe pero el nivel es incorrecto (debería ser # 'root.artefacto', no solo 'artefacto') interior = Coleccion("interior", self.artefacto) with raises(KeyError): Coleccion("raiz", interior).configuracion("artefacto") def claves_no_tienen_que_existir_en_la_ruta_completa(self): # Un poco duplica cosas anteriores; bah Clave solo almacenada # en hoja hoja = Coleccion("hoja", self.artefacto) hoja.configurar({"clave": "hoja-valor"}) medio = Coleccion("medio", hoja) raiz = Coleccion("raiz", medio) config = raiz.configuracion("medio.hoja.artefacto") assert config == {"clave": "hoja-valor"} # Clave almacenada en medio + hoja pero no raíz medio.configurar({"clave": "soo"}) assert raiz.configuracion("medio.hoja.artefacto") == { "clave": "soo" }
class ad_artefacto: def setup(self): self.c = Coleccion() def asociados_dados_invocables_con_nombre_dado(self): self.c.ad_artefacto(_miartefacto, "foo") assert self.c["foo"] == _miartefacto def usa_nombre_de_la_funcion_como_nombre_implicito(self): self.c.ad_artefacto(_miartefacto) assert "_miartefacto" in self.c def prefiere_el_nombre_kwarg_sobre_el_atributo_nombre_del_artefacto( self): self.c.ad_artefacto(Artefacto(_func, nombre="nofunc"), nombre="sifunc") assert "sifunc" in self.c assert "nofunc" not in self.c def prefiere_el_atributo_de_nombre_de_artefacto_sobre_el_nombre_de_funcion( self): self.c.ad_artefacto(Artefacto(_func, nombre="nofunc")) assert "nofunc" in self.c assert "_func" not in self.c def genera_ValueError_si_no_se_encuentra_ningun_nombre(self): # No se puede usar una lambda aquí porque son funciones técnicamente reales. class Invocable(object): def __call__(self): pass with raises(ValueError): self.c.ad_artefacto(Artefacto(Invocable())) def genera_ValueError_en_multiples_defaults(self): t1 = Artefacto(_func, default=True) t2 = Artefacto(_func, default=True) self.c.ad_artefacto(t1, "foo") with raises(ValueError): self.c.ad_artefacto(t2, "bar") def genera_ValueError_si_elartefacto_agregado_refleja_el_nombre_de_la_subcoleccion( self): self.c.ad_coleccion(Coleccion("sub")) with raises(ValueError): self.c.ad_artefacto(_miartefacto, "sub") def permite_especificar_el_artefacto_por_defecto(self): self.c.ad_artefacto(_miartefacto, default=True) assert self.c.default == "_miartefacto" def especificando_el_seteo_del_artefacto_pordefecto_False_anulacion( self): @artefacto(default=True) def soy_yo(c): pass self.c.ad_artefacto(soy_yo, default=False) assert self.c.default is None def permite_especificar_alias(self): self.c.ad_artefacto(_miartefacto, alias=("artefacto1", "artefacto2")) assert self.c["_miartefacto"] is self.c["artefacto1"] is self.c[ "artefacto2"] def alias_son_fundidos(self): @artefacto(alias=("foo", "bar")) def biz(c): pass # NOTE: use la tupla anterior y la lista a continuación para # asegurarse de que no haya problemas de tipo self.c.ad_artefacto(biz, alias=["baz", "boz"]) for x in ("foo", "bar", "biz", "baz", "boz"): assert self.c[x] is self.c["biz"]