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 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 yaml_evita_yml_json_o_python(self):
c = Config(sistema_prefijo=join(CONFIGS_RUTA, "los-cuatro/"))
assert "solo-json" not in c
assert "solo_python" not in c
assert "solo-yml" not in c
assert "solo-yaml" in c
assert c.shared == "yaml-valor"
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 setitem(self):
c = Config(defaults={"foo": "bar"})
c["foo"] = "nobar"
assert c.foo == "nobar"
del c["foo"]
c["anidado"] = {"hojaclave": "hojavalor"}
assert c == {"anidado": {"hojaclave": "hojavalor"}}
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 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 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 archivos_inexistentes_se_omiten_y_registran(self, mock_debug):
c = Config()
c._cargar_yml = Mock(efecto_secundario=IOError(2, "oh nueces"))
c.setea_acte_ruta("es-un.yml") # Desencadena el uso de _cargar_yml
c.cargar_acte()
mock_debug.assert_cualquier_llamada(
"No vi ningún es-un.yml, saltando.")
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 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 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 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 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 limpiar(self):
c = Config(defaults={"foo": "bar"})
c.limpiar()
assert c == {}
c.anidado = {"hojaclave": "hojavalor"}
c.anidado.clear()
assert c == {"anidado": {}}
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 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 eliminar_las_claves_principales_de_las_claves_eliminadas_las_subsume(
self):
c = Config({"foo": {"bar": "biz"}})
del c.foo["bar"]
del c.foo
# Asegúrate de no terminar de alguna manera con
# {'foo': {'bar': None}}
assert c._eliminaciones == {"foo": None}
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 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 subclaves_se_combinan_no_se_sobrescriben(self):
# Asegura que las claves anidadas se fusionen profundamente
# en lugar de superficialmente.
defaults = {"foo": {"bar": "baz"}}
anulaciones = {"foo": {"nobar": "nobaz"}}
c = Config(defaults=defaults, anulaciones=anulaciones)
assert c.foo.nobar == "nobaz"
assert c.foo.bar == "baz"
def genera_TypeError_si_value_no_es_la_subclase_Config(self):
try:
Config().clonar(dentro=17)
except TypeError:
pass
else:
assert False, "¡El obj que no-es-clase no generó TypeError!"
class Foo(object):
pass
try:
Config().clonar(dentro=Foo)
except TypeError:
pass
else:
assert False, "Non-subclass no genera TypeError!"
def tiempoej_anulan_proyecto(self):
c = Config(
acte_ruta=join(CONFIGS_RUTA, "json", "dued.json"),
dir_de_py=join(CONFIGS_RUTA, "yaml"),
)
c.cargar_acte()
c.cargar_proyecto()
assert c.exterior.interior.hurra == "json"
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 puede_aplazar_la_carga_de_arch_de_sistema_y_de_usuario(
self, cargar_u, cargar_s):
config = Config(lento=True)
assert not cargar_s.called
assert not cargar_u.called
# ¡Asegúrese de que los niveles predeterminados sigan en su lugar!
# (Cuando hay un error, es decir, combinar() nunca se llama, la
# configuración aparece efectivamente vacía).
assert config.correr.echo is False
def admite_protocolos_de_dic_de_solo_lectura(self):
# Utilice un de un solo par de claves para evitar problemas de
# clasificación en las pruebas.
c = Config(defaults={"foo": "bar"})
c2 = Config(defaults={"foo": "bar"})
assert "foo" in c
assert "foo" in c2 # principalmente solo para activar la carga: x
assert c == c2
assert len(c) == 1
assert c.get("foo") == "bar"
if six.PY2:
assert c.has_key("foo") is True # noqa
assert list(c.iterkeys()) == ["foo"]
assert list(c.itervalues()) == ["bar"]
assert list(c.items()) == [("foo", "bar")]
assert list(six.iteritems(c)) == [("foo", "bar")]
assert list(c.keys()) == ["foo"]
assert list(c.values()) == ["bar"]
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 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 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"
