def clones_resultantes_se_escriben_como_nueva_clase(self):
class MiConfig(Config):
pass
c = Config()
c2 = c.clonar(dentro=MiConfig)
assert type(c2) is MiConfig
def tiempoej_anula_todo_el_sistema(self):
c = Config(
acte_ruta=join(CONFIGS_RUTA, "json", "dued.json"),
sistema_prefijo=join(CONFIGS_RUTA, "yaml/"),
)
c.cargar_acte()
assert c.exterior.interior.hurra == "json"
def conserva_miembros_basicos(self):
c1 = Config(
defaults={"clave": "default"},
anulaciones={"clave": "anular"},
sistema_prefijo="global",
ususario_prefijo="usuario",
dir_de_py="proyecto",
acte_ruta="acte.yaml",
)
c2 = c1.clonar()
# NOTE: esperando valores por defecto idénticos también pruebas
# implícitamente que clonar() pasa en defaults= en lugar de hacer
# un init + copy vacío. (Cuando ese no es el caso, terminamos con
# global_defaults() que se vuelve a ejecutar y se vuelve
# a agregar a _defaults ...)
assert c2._defaults == c1._defaults
assert c2._defaults is not c1._defaults
assert c2._anula == c1._anula
assert c2._anula is not c1._anula
assert c2._sistema_prefijo == c1._sistema_prefijo
assert c2._ususario_prefijo == c1._ususario_prefijo
assert c2._proyecto_prefijo == c1._proyecto_prefijo
assert c2.prefijo == c1.prefijo
assert c2.archivo_prefijo == c1.archivo_prefijo
assert c2.entorno_prefijo == c1.entorno_prefijo
assert c2._ruta_al_acte == c1._ruta_al_acte
def la_combinacion_se_puede_diferir(self):
c = Config()
assert "foo" not in c._coleccion
assert "foo" not in c
c.cargar_coleccion({"foo": "bar"}, combinar=False)
assert "foo" in c._coleccion
assert "foo" not in c
def entradas_tipo_booleano_con_valores_pordefecto_no_booleanos(
self):
for entrada_ in ("0", "1", "", "bah", "false"):
os.environ["DUED_FOO"] = entrada_
c = Config(defaults={"foo": "bar"})
c.cargar_entorno_shell()
assert c.foo == entrada_
def especifico_del_py(self):
"Local-to-project conf files"
for tipo_ in TIPOS:
c = Config(dir_de_py=join(CONFIGS_RUTA, tipo_))
assert "exterior" not in c
c.cargar_proyecto()
assert c.exterior.interior.hurra == tipo_
def proyecto_anula_al_usuario(self):
c = Config(
ususario_prefijo=join(CONFIGS_RUTA, "json/"),
dir_de_py=join(CONFIGS_RUTA, "yaml"),
)
c.cargar_proyecto()
assert c.exterior.interior.hurra == "yaml"
def tiempoej_anulan_ususario(self):
c = Config(
acte_ruta=join(CONFIGS_RUTA, "json", "dued.json"),
ususario_prefijo=join(CONFIGS_RUTA, "yaml/"),
)
c.cargar_acte()
assert c.exterior.interior.hurra == "json"
def proyecto_anula_todo_el_sistema(self):
c = Config(
sistema_prefijo=join(CONFIGS_RUTA, "json/"),
dir_de_py=join(CONFIGS_RUTA, "yaml"),
)
c.cargar_proyecto()
assert c.exterior.interior.hurra == "yaml"
def popitem(self):
c = Config(defaults={"foo": "bar"})
assert c.popitem() == ("foo", "bar")
assert c == {}
c.anidado = {"hojaclave": "hojavalor"}
assert c.anidado.popitem() == ("hojaclave", "hojavalor")
assert c == {"anidado": {}}
def limpiar(self):
c = Config(defaults={"foo": "bar"})
c.limpiar()
assert c == {}
c.anidado = {"hojaclave": "hojavalor"}
c.anidado.clear()
assert c == {"anidado": {}}
def realizado_explicita_y_directamente(self):
# TODO: ¿queremos actualizar los otros niveles para permitir
# una carga 'directa' como esta, ahora que todos tienen métodos
# explícitos?
c = Config()
assert "foo" not in c
c.cargar_coleccion({"foo": "bar"})
assert c.foo == "bar"
def delitem(self):
"__delitem__"
c = Config(defaults={"foo": "bar"})
del c["foo"]
assert c == {}
c.anidado = {"hojaclave": "hojavalor"}
del c.anidado["hojaclave"]
assert c == {"anidado": {}}
def delattr(self):
"__delattr__"
c = Config(defaults={"foo": "bar"})
del c.foo
assert c == {}
c.anidado = {"hojaclave": "hojavalor"}
del c.anidado.hojaclave
assert c == {"anidado": {}}
def comparacion_mira_la_config_combinada(self):
c1 = Config(defaults={"foo": {"bar": "biz"}})
# Valores predeterminados vacíos para suprimir
# global_defaults
c2 = Config(defaults={}, anulaciones={"foo": {"bar": "biz"}})
assert c1 is not c2
assert c1._defaults != c2._defaults
assert c1 == c2
def conserva_config_combinada(self):
c = Config(defaults={"clave": "default"},
anulaciones={"clave": "anular"})
assert c.clave == "anular"
assert c._defaults["clave"] == "default"
c2 = c.clonar()
assert c2.clave == "anular"
assert c2._defaults["clave"] == "default"
assert c2._anula["clave"] == "anular"
def py_puede_omitir_la_combinacion(self):
config = Config(dir_de_py=join(CONFIGS_RUTA, "yml"), lento=True)
assert "exterior" not in config._py
assert "exterior" not in config
config.cargar_proyecto(combinar=False)
# Prueba que cargamos en el dicc por nivel, pero no en la
# configuración central/fusionada.
assert "exterior" in config._py
assert "exterior" not in config
def pueden_establecer_atrib_inexistentes_para_crear_nuevas_config_de_nivel_sup(
self):
# Es decir algun_configfoo = 'bar' es como algun_config['foo'] = 'bar'.
# Cuando esta prueba se rompe, generalmente significa que
# algun_config.foo = 'bar' establece un atributo regular,
# ¡y la configuración en sí nunca se toca!
c = Config()
c.algun_ajuste = "algun_valor"
assert c["algun_ajuste"] == "algun_valor"
def usuario_anula_la_colección(self):
c = Config(ususario_prefijo=join(CONFIGS_RUTA, "json/"))
c.cargar_coleccion(
{"exterior": {
"interior": {
"hurra": "defaults"
}
}})
assert c.exterior.interior.hurra == "json"
def coleccion_de_anulaciones_en_todo_el_sistema(self):
c = Config(sistema_prefijo=join(CONFIGS_RUTA, "yaml/"))
c.cargar_coleccion(
{"exterior": {
"interior": {
"hurra": "defaults"
}
}})
assert c.exterior.interior.hurra == "yaml"
def tiempoej_puede_omitir_la_combinacion(self):
ruta = join(CONFIGS_RUTA, "yaml", "dued.yaml")
config = Config(acte_ruta=ruta, lento=True)
assert "exterior" not in config._acte
assert "exterior" not in config
config.cargar_acte(combinar=False)
# Prueba que cargamos en el dicc por nivel, pero no en la
# configuración central/fusionada.
assert "exterior" in config._acte
assert "exterior" not in config
def unicode_reemplazado_por_el_valor_entorno(self):
# Python 3 no le permite poner objetos 'bytes' en
# os.environ, por lo que la prueba no tiene sentido allí.
if six.PY3:
return
os.environ["DUED_FOO"] = "miunicode"
c = Config(defaults={"foo": u"miviejovalor"})
c.cargar_entorno_shell()
assert c.foo == "miunicode"
assert isinstance(c.foo, str)
def no_carga_archivo_especifico_del_py_si_no_proporciona_la_ubic_del_py(
self):
c = Config()
assert c._proyecto_ruta is None
c.cargar_proyecto()
assert list(c._py.keys()) == []
defaults = [
"artefactos", "correr", "corredores", "sudo",
"tiempo_de_descanso"
]
assert set(c.keys()) == set(defaults)
def pop(self):
# Raiz
c = Config(defaults={"foo": "bar"})
assert c.pop("foo") == "bar"
assert c == {}
# Con el arg predeterminado
assert c.pop("hum", "bien entonces") == "bien entonces"
# Hoja (clave diferente para evitar ErrorDeFusionAmbiguo)
c.anidado = {"hojaclave": "hojavalor"}
assert c.anidado.pop("hojaclave") == "hojavalor"
assert c == {"anidado": {}}
def booleanos(self):
for entrada_, resultado in (
("0", False),
("1", True),
("", False),
("bah", True),
("false", True),
):
os.environ["DUED_FOO"] = entrada_
c = Config(defaults={"foo": bool()})
c.cargar_entorno_shell()
assert c.foo == resultado
def tipos_arbitrarios_tambien_trabajan(self):
os.environ["DUED_FOO"] = "cualquier"
class Meh(object):
def __init__(self, thing=None):
pass
obj_viejo = Meh()
c = Config(defaults={"foo": obj_viejo})
c.cargar_entorno_shell()
assert isinstance(c.foo, Meh)
assert c.foo is not obj_viejo
def setdefault(self):
c = Config({
"foo": "bar",
"anidado": {
"hojaclave": "hojavalor"
}
})
assert c.setdefault("foo") == "bar"
assert c.anidado.setdefault("hojaclave") == "hojavalor"
assert c.setdefault("notfoo", "nobar") == "nobar"
assert c.notfoo == "nobar"
anidado = c.anidado.setdefault("otrahoja", "otroval")
assert anidado == "otroval"
assert c.anidado.otrahoja == "otroval"
def actualizar(self):
c = Config(defaults={
"foo": "bar",
"anidado": {
"hojaclave": "hojavalor"
}
})
# Regular : actualizar(dic)
c.actualizar({"foo": "nobar"})
assert c.foo == "nobar"
c.anidado.actualizar({"hojaclave": "otroval"})
assert c.anidado.hojaclave == "otroval"
# Aparentemente permitido pero completamente inútil.
c.actualizar()
esperado = {
"foo": "nobar",
"anidado": {
"hojaclave": "otroval"
}
}
assert c == esperado
# Kwarg edition
c.actualizar(foo="otrobar")
assert c.foo == "otrobar"
# Iterator of 2-tuples edition
c.anidado.actualizar([("hojaclave", "otrovalormas"),
("newhoja", "giro")])
assert c.anidado.hojaclave == "otrovalormas"
assert c.anidado.newhoja == "giro"
def restablecimiento_de_los_valores_eliminados_funciona_ok(self):
# Suena como una estupidez para probar, pero cuando tenemos que
# rastrear eliminaciones y mutaciones manualmente ... es algo
# fácil de pasar por alto
c = Config(defaults={"foo": "bar"})
assert c.foo == "bar"
del c["foo"]
# Controles de cordura
assert "foo" not in c
assert len(c) == 0
# Vuelvi a ponerlo ... como un valor diferente, por diversión
c.foo = "antiguamente bar"
# Y asegúrate de que se atasque
assert c.foo == "antiguamente bar"
def la_combinacion_no_borra_las_modificaciones_o_eliminaciones_del_usuario(
self):
c = Config({"foo": {"bar": "biz"}, "error": True})
c.foo.bar = "nobiz"
del c["error"]
assert c["foo"]["bar"] == "nobiz"
assert "error" not in c
c.combinar()
# Volverá a 'biz' si los cambios del usuario no se guardan por sí
# mismos (anteriormente eran solo mutaciones en la configuración
# central almacenada en caché)
assert c["foo"]["bar"] == "nobiz"
# Y esto todavía estaría aquí también
assert "error" not in c