mirror of
https://github.com/planetmint/planetmint.git
synced 2025-03-30 15:08:31 +00:00
325 lines
11 KiB
Python
325 lines
11 KiB
Python
# Copyright © 2020 Interplanetary Database Association e.V.,
|
|
# Planetmint and IPDB software contributors.
|
|
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
|
|
# Code is Apache-2.0 and docs are CC-BY-4.0
|
|
|
|
import pytest
|
|
import planetmint
|
|
|
|
from unittest.mock import mock_open, patch
|
|
from planetmint.config import Config
|
|
|
|
|
|
@pytest.fixture(scope="function", autouse=True)
|
|
def clean_config(monkeypatch, request):
|
|
original_config = Config().init_config("tarantool_db")
|
|
backend = request.config.getoption("--database-backend")
|
|
original_config["database"] = Config().get_db_map(backend)
|
|
monkeypatch.setattr("planetmint.config", original_config)
|
|
|
|
|
|
def test_bigchain_instance_is_initialized_when_conf_provided():
|
|
from planetmint import config_utils
|
|
|
|
assert "CONFIGURED" not in Config().get()
|
|
|
|
config_utils.set_config({"database": {"backend": "a"}})
|
|
|
|
assert Config().get()["CONFIGURED"] is True
|
|
|
|
|
|
def test_load_validation_plugin_loads_default_rules_without_name():
|
|
from planetmint import config_utils
|
|
from planetmint.validation import BaseValidationRules
|
|
|
|
assert config_utils.load_validation_plugin() == BaseValidationRules
|
|
|
|
|
|
def test_load_validation_plugin_raises_with_unknown_name():
|
|
from pkg_resources import ResolutionError
|
|
from planetmint import config_utils
|
|
|
|
with pytest.raises(ResolutionError):
|
|
config_utils.load_validation_plugin("bogus")
|
|
|
|
|
|
def test_load_validation_plugin_raises_with_invalid_subclass(monkeypatch):
|
|
# Monkeypatch entry_point.load to return something other than a
|
|
# ValidationRules instance
|
|
from planetmint import config_utils
|
|
import time
|
|
|
|
monkeypatch.setattr(
|
|
config_utils, "iter_entry_points", lambda *args: [type("entry_point", (object,), {"load": lambda: object})]
|
|
)
|
|
|
|
with pytest.raises(TypeError):
|
|
# Since the function is decorated with `lru_cache`, we need to
|
|
# "miss" the cache using a name that has not been used previously
|
|
config_utils.load_validation_plugin(str(time.time()))
|
|
|
|
|
|
def test_load_events_plugins(monkeypatch):
|
|
from planetmint import config_utils
|
|
|
|
monkeypatch.setattr(
|
|
config_utils, "iter_entry_points", lambda *args: [type("entry_point", (object,), {"load": lambda: object})]
|
|
)
|
|
|
|
plugins = config_utils.load_events_plugins(["one", "two"])
|
|
assert len(plugins) == 2
|
|
|
|
|
|
def test_map_leafs_iterator():
|
|
from planetmint import config_utils
|
|
|
|
mapping = {"a": {"b": {"c": 1}, "d": {"z": 44}}, "b": {"d": 2}, "c": 3}
|
|
|
|
result = config_utils.map_leafs(lambda x, path: x * 2, mapping)
|
|
assert result == {"a": {"b": {"c": 2}, "d": {"z": 88}}, "b": {"d": 4}, "c": 6}
|
|
|
|
result = config_utils.map_leafs(lambda x, path: path, mapping)
|
|
assert result == {
|
|
"a": {"b": {"c": ["a", "b", "c"]}, "d": {"z": ["a", "d", "z"]}},
|
|
"b": {"d": ["b", "d"]},
|
|
"c": ["c"],
|
|
}
|
|
|
|
|
|
def test_update_types():
|
|
from planetmint import config_utils
|
|
|
|
raw = {
|
|
"a_string": "test",
|
|
"an_int": "42",
|
|
"a_float": "3.14",
|
|
"a_list": "a:b:c",
|
|
}
|
|
|
|
reference = {
|
|
"a_string": "test",
|
|
"an_int": 42,
|
|
"a_float": 3.14,
|
|
"a_list": ["a", "b", "c"],
|
|
}
|
|
|
|
result = config_utils.update_types(raw, reference)
|
|
assert result == reference
|
|
|
|
|
|
def test_env_config(monkeypatch):
|
|
monkeypatch.setattr(
|
|
"os.environ", {"PLANETMINT_DATABASE_HOST": "test-host", "PLANETMINT_DATABASE_PORT": "test-port"}
|
|
)
|
|
|
|
from planetmint import config_utils
|
|
|
|
result = config_utils.env_config({"database": {"host": None, "port": None}})
|
|
expected = {"database": {"host": "test-host", "port": "test-port"}}
|
|
|
|
assert result == expected
|
|
|
|
|
|
@pytest.mark.skip
|
|
def test_autoconfigure_read_both_from_file_and_env(
|
|
monkeypatch, request
|
|
): # TODO Disabled until we create a better config format
|
|
return
|
|
# constants
|
|
DATABASE_HOST = "test-host"
|
|
DATABASE_NAME = "test-dbname"
|
|
DATABASE_PORT = 4242
|
|
DATABASE_BACKEND = request.config.getoption("--database-backend")
|
|
SERVER_BIND = "1.2.3.4:56"
|
|
WSSERVER_SCHEME = "ws"
|
|
WSSERVER_HOST = "1.2.3.4"
|
|
WSSERVER_PORT = 57
|
|
WSSERVER_ADVERTISED_SCHEME = "wss"
|
|
WSSERVER_ADVERTISED_HOST = "a.b.c.d"
|
|
WSSERVER_ADVERTISED_PORT = 89
|
|
LOG_FILE = "/somewhere/something.log"
|
|
|
|
file_config = {
|
|
"database": {"host": DATABASE_HOST},
|
|
"log": {
|
|
"level_console": "debug",
|
|
},
|
|
}
|
|
|
|
monkeypatch.setattr("planetmint.config_utils.file_config", lambda *args, **kwargs: file_config)
|
|
|
|
monkeypatch.setattr(
|
|
"os.environ",
|
|
{
|
|
"PLANETMINT_DATABASE_NAME": DATABASE_NAME,
|
|
"PLANETMINT_DATABASE_PORT": str(DATABASE_PORT),
|
|
"PLANETMINT_DATABASE_BACKEND": DATABASE_BACKEND,
|
|
"PLANETMINT_SERVER_BIND": SERVER_BIND,
|
|
"PLANETMINT_WSSERVER_SCHEME": WSSERVER_SCHEME,
|
|
"PLANETMINT_WSSERVER_HOST": WSSERVER_HOST,
|
|
"PLANETMINT_WSSERVER_PORT": WSSERVER_PORT,
|
|
"PLANETMINT_WSSERVER_ADVERTISED_SCHEME": WSSERVER_ADVERTISED_SCHEME,
|
|
"PLANETMINT_WSSERVER_ADVERTISED_HOST": WSSERVER_ADVERTISED_HOST,
|
|
"PLANETMINT_WSSERVER_ADVERTISED_PORT": WSSERVER_ADVERTISED_PORT,
|
|
"PLANETMINT_LOG_FILE": LOG_FILE,
|
|
"PLANETMINT_LOG_FILE": LOG_FILE,
|
|
"PLANETMINT_DATABASE_CA_CERT": "ca_cert",
|
|
"PLANETMINT_DATABASE_CRLFILE": "crlfile",
|
|
"PLANETMINT_DATABASE_CERTFILE": "certfile",
|
|
"PLANETMINT_DATABASE_KEYFILE": "keyfile",
|
|
"PLANETMINT_DATABASE_KEYFILE_PASSPHRASE": "passphrase",
|
|
},
|
|
)
|
|
|
|
from planetmint import config_utils
|
|
from planetmint.log import DEFAULT_LOGGING_CONFIG as log_config
|
|
|
|
config_utils.autoconfigure()
|
|
|
|
database_mongodb = {
|
|
"backend": "localmongodb",
|
|
"host": DATABASE_HOST,
|
|
"port": DATABASE_PORT,
|
|
"name": DATABASE_NAME,
|
|
"connection_timeout": 5000,
|
|
"max_tries": 3,
|
|
"replicaset": None,
|
|
"ssl": False,
|
|
"login": None,
|
|
"password": None,
|
|
"ca_cert": "ca_cert",
|
|
"certfile": "certfile",
|
|
"keyfile": "keyfile",
|
|
"keyfile_passphrase": "passphrase",
|
|
"crlfile": "crlfile",
|
|
}
|
|
|
|
assert planetmint.config == {
|
|
"CONFIGURED": True,
|
|
"server": {
|
|
"bind": SERVER_BIND,
|
|
"loglevel": "info",
|
|
"workers": None,
|
|
},
|
|
"wsserver": {
|
|
"scheme": WSSERVER_SCHEME,
|
|
"host": WSSERVER_HOST,
|
|
"port": WSSERVER_PORT,
|
|
"advertised_scheme": WSSERVER_ADVERTISED_SCHEME,
|
|
"advertised_host": WSSERVER_ADVERTISED_HOST,
|
|
"advertised_port": WSSERVER_ADVERTISED_PORT,
|
|
},
|
|
"database": database_mongodb,
|
|
"tendermint": {"host": "localhost", "port": 26657, "version": "v0.34.15"},
|
|
"log": {
|
|
"file": LOG_FILE,
|
|
"level_console": "debug",
|
|
"error_file": log_config["handlers"]["errors"]["filename"],
|
|
"level_console": "debug",
|
|
"level_logfile": "info",
|
|
"datefmt_console": log_config["formatters"]["console"]["datefmt"],
|
|
"datefmt_logfile": log_config["formatters"]["file"]["datefmt"],
|
|
"fmt_console": log_config["formatters"]["console"]["format"],
|
|
"fmt_logfile": log_config["formatters"]["file"]["format"],
|
|
"granular_levels": {},
|
|
},
|
|
}
|
|
|
|
|
|
def test_autoconfigure_env_precedence(monkeypatch):
|
|
file_config = {"database": {"host": "test-host", "name": "planetmint", "port": 28015}}
|
|
monkeypatch.setattr("planetmint.config_utils.file_config", lambda *args, **kwargs: file_config)
|
|
monkeypatch.setattr(
|
|
"os.environ",
|
|
{
|
|
"PLANETMINT_DATABASE_NAME": "test-dbname",
|
|
"PLANETMINT_DATABASE_PORT": 4242,
|
|
"PLANETMINT_SERVER_BIND": "localhost:9985",
|
|
},
|
|
)
|
|
from planetmint import config_utils
|
|
from planetmint.config import Config
|
|
|
|
config_utils.autoconfigure()
|
|
|
|
assert Config().get()["CONFIGURED"]
|
|
assert Config().get()["database"]["host"] == "test-host"
|
|
assert Config().get()["database"]["name"] == "test-dbname"
|
|
assert Config().get()["database"]["port"] == 4242
|
|
assert Config().get()["server"]["bind"] == "localhost:9985"
|
|
|
|
|
|
def test_autoconfigure_explicit_file(monkeypatch):
|
|
from planetmint import config_utils
|
|
|
|
def file_config(*args, **kwargs):
|
|
raise FileNotFoundError()
|
|
|
|
monkeypatch.setattr("planetmint.config_utils.file_config", file_config)
|
|
|
|
with pytest.raises(FileNotFoundError):
|
|
config_utils.autoconfigure(filename="autoexec.bat")
|
|
|
|
|
|
def test_update_config(monkeypatch):
|
|
from planetmint import config_utils
|
|
|
|
file_config = {"database": {"host": "test-host", "name": "planetmint", "port": 28015}}
|
|
monkeypatch.setattr("planetmint.config_utils.file_config", lambda *args, **kwargs: file_config)
|
|
config_utils.autoconfigure(config=file_config)
|
|
|
|
# update configuration, retaining previous changes
|
|
config_utils.update_config({"database": {"port": 28016, "name": "planetmint_other"}})
|
|
|
|
assert Config().get()["database"]["host"] == "test-host"
|
|
assert Config().get()["database"]["name"] == "planetmint_other"
|
|
assert Config().get()["database"]["port"] == 28016
|
|
|
|
|
|
def test_file_config():
|
|
from planetmint.config_utils import file_config, CONFIG_DEFAULT_PATH
|
|
|
|
with patch("builtins.open", mock_open(read_data="{}")) as m:
|
|
config = file_config()
|
|
m.assert_called_once_with(CONFIG_DEFAULT_PATH)
|
|
assert config == {}
|
|
|
|
|
|
def test_invalid_file_config():
|
|
from planetmint.config_utils import file_config
|
|
from transactions.common import exceptions
|
|
|
|
with patch("builtins.open", mock_open(read_data="{_INVALID_JSON_}")):
|
|
with pytest.raises(exceptions.ConfigurationError):
|
|
file_config()
|
|
|
|
|
|
def test_write_config():
|
|
from planetmint.config_utils import write_config, CONFIG_DEFAULT_PATH
|
|
|
|
m = mock_open()
|
|
with patch("builtins.open", m):
|
|
write_config({})
|
|
m.assert_called_once_with(CONFIG_DEFAULT_PATH, "w")
|
|
handle = m()
|
|
handle.write.assert_called_once_with("{}")
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"env_name,env_value,config_key",
|
|
(
|
|
("PLANETMINT_DATABASE_BACKEND", "test-backend", "backend"),
|
|
("PLANETMINT_DATABASE_HOST", "test-host", "host"),
|
|
("PLANETMINT_DATABASE_PORT", 4242, "port"),
|
|
("PLANETMINT_DATABASE_NAME", "test-db", "name"),
|
|
),
|
|
)
|
|
def test_database_envs(env_name, env_value, config_key, monkeypatch):
|
|
monkeypatch.setattr("os.environ", {env_name: env_value})
|
|
planetmint.config_utils.autoconfigure()
|
|
|
|
expected_config = Config().get()
|
|
expected_config["database"][config_key] = env_value
|
|
|
|
assert planetmint.config == expected_config
|