You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 lines
13 KiB
293 lines
13 KiB
import ast |
|
import sys |
|
import os |
|
import tempfile |
|
import shutil |
|
from io import StringIO |
|
|
|
from electrum.simple_config import SimpleConfig, read_user_config |
|
from electrum import constants |
|
|
|
from . import ElectrumTestCase |
|
|
|
|
|
MAX_MSG_SIZE_DEFAULT = SimpleConfig.NETWORK_MAX_INCOMING_MSG_SIZE.get_default_value() |
|
assert isinstance(MAX_MSG_SIZE_DEFAULT, int), MAX_MSG_SIZE_DEFAULT |
|
|
|
|
|
class Test_SimpleConfig(ElectrumTestCase): |
|
|
|
def setUp(self): |
|
super(Test_SimpleConfig, self).setUp() |
|
# make sure "read_user_config" and "user_dir" return a temporary directory. |
|
self.electrum_dir = tempfile.mkdtemp() |
|
# Do the same for the user dir to avoid overwriting the real configuration |
|
# for development machines with electrum installed :) |
|
self.user_dir = tempfile.mkdtemp() |
|
|
|
self.options = {"electrum_path": self.electrum_dir} |
|
self._saved_stdout = sys.stdout |
|
self._stdout_buffer = StringIO() |
|
sys.stdout = self._stdout_buffer |
|
|
|
def tearDown(self): |
|
super(Test_SimpleConfig, self).tearDown() |
|
# Remove the temporary directory after each test (to make sure we don't |
|
# pollute /tmp for nothing. |
|
shutil.rmtree(self.electrum_dir) |
|
shutil.rmtree(self.user_dir) |
|
|
|
# Restore the "real" stdout |
|
sys.stdout = self._saved_stdout |
|
|
|
def test_simple_config_key_rename(self): |
|
"""auto_cycle was renamed auto_connect""" |
|
fake_read_user = lambda _: {"auto_cycle": True} |
|
read_user_dir = lambda : self.user_dir |
|
config = SimpleConfig(options=self.options, |
|
read_user_config_function=fake_read_user, |
|
read_user_dir_function=read_user_dir) |
|
self.assertEqual(config.get("auto_connect"), True) |
|
self.assertEqual(config.get("auto_cycle"), None) |
|
fake_read_user = lambda _: {"auto_connect": False, "auto_cycle": True} |
|
config = SimpleConfig(options=self.options, |
|
read_user_config_function=fake_read_user, |
|
read_user_dir_function=read_user_dir) |
|
self.assertEqual(config.get("auto_connect"), False) |
|
self.assertEqual(config.get("auto_cycle"), None) |
|
|
|
def test_simple_config_command_line_overrides_everything(self): |
|
"""Options passed by command line override all other configuration |
|
sources""" |
|
fake_read_user = lambda _: {"electrum_path": "b"} |
|
read_user_dir = lambda : self.user_dir |
|
config = SimpleConfig(options=self.options, |
|
read_user_config_function=fake_read_user, |
|
read_user_dir_function=read_user_dir) |
|
self.assertEqual(self.options.get("electrum_path"), |
|
config.get("electrum_path")) |
|
|
|
def test_simple_config_user_config_is_used_if_others_arent_specified(self): |
|
"""If no system-wide configuration and no command-line options are |
|
specified, the user configuration is used instead.""" |
|
fake_read_user = lambda _: {"electrum_path": self.electrum_dir} |
|
read_user_dir = lambda : self.user_dir |
|
config = SimpleConfig(options={}, |
|
read_user_config_function=fake_read_user, |
|
read_user_dir_function=read_user_dir) |
|
self.assertEqual(self.options.get("electrum_path"), |
|
config.get("electrum_path")) |
|
|
|
def test_cannot_set_options_passed_by_command_line(self): |
|
fake_read_user = lambda _: {"electrum_path": "b"} |
|
read_user_dir = lambda : self.user_dir |
|
config = SimpleConfig(options=self.options, |
|
read_user_config_function=fake_read_user, |
|
read_user_dir_function=read_user_dir) |
|
config.set_key("electrum_path", "c") |
|
self.assertEqual(self.options.get("electrum_path"), |
|
config.get("electrum_path")) |
|
|
|
def test_can_set_options_set_in_user_config(self): |
|
another_path = tempfile.mkdtemp() |
|
fake_read_user = lambda _: {"electrum_path": self.electrum_dir} |
|
read_user_dir = lambda : self.user_dir |
|
config = SimpleConfig(options={}, |
|
read_user_config_function=fake_read_user, |
|
read_user_dir_function=read_user_dir) |
|
config.set_key("electrum_path", another_path) |
|
self.assertEqual(another_path, config.get("electrum_path")) |
|
|
|
def test_user_config_is_not_written_with_read_only_config(self): |
|
"""The user config does not contain command-line options when saved.""" |
|
fake_read_user = lambda _: {"something": "a"} |
|
read_user_dir = lambda : self.user_dir |
|
self.options.update({"something": "c"}) |
|
config = SimpleConfig(options=self.options, |
|
read_user_config_function=fake_read_user, |
|
read_user_dir_function=read_user_dir) |
|
config.save_user_config() |
|
contents = None |
|
with open(os.path.join(self.electrum_dir, "config"), "r") as f: |
|
contents = f.read() |
|
result = ast.literal_eval(contents) |
|
result.pop('config_version', None) |
|
self.assertEqual({"something": "a"}, result) |
|
|
|
def test_configvars_set_and_get(self): |
|
config = SimpleConfig(self.options) |
|
self.assertEqual("server", config.cv.NETWORK_SERVER.key()) |
|
|
|
def _set_via_assignment(): |
|
config.NETWORK_SERVER = "example.com:443:s" |
|
|
|
for f in ( |
|
lambda: config.set_key("server", "example.com:443:s"), |
|
_set_via_assignment, |
|
lambda: config.cv.NETWORK_SERVER.set("example.com:443:s"), |
|
): |
|
self.assertTrue(config.get("server") is None) |
|
self.assertTrue(config.NETWORK_SERVER is None) |
|
self.assertTrue(config.cv.NETWORK_SERVER.get() is None) |
|
f() |
|
self.assertEqual("example.com:443:s", config.get("server")) |
|
self.assertEqual("example.com:443:s", config.NETWORK_SERVER) |
|
self.assertEqual("example.com:443:s", config.cv.NETWORK_SERVER.get()) |
|
# revert: |
|
config.NETWORK_SERVER = None |
|
|
|
def test_configvars_get_default_value(self): |
|
config = SimpleConfig(self.options) |
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.get_default_value()) |
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
|
|
config.NETWORK_MAX_INCOMING_MSG_SIZE = 5_555_555 |
|
self.assertEqual(5_555_555, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.get_default_value()) |
|
|
|
config.NETWORK_MAX_INCOMING_MSG_SIZE = None |
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
|
|
def test_configvars_get_default_value_complex_fn(self): |
|
config = SimpleConfig(self.options) |
|
self.assertEqual("https://swaps.electrum.org/api", config.SWAPSERVER_URL) |
|
|
|
config.SWAPSERVER_URL = "http://localhost:9999" |
|
self.assertEqual("http://localhost:9999", config.SWAPSERVER_URL) |
|
|
|
config.SWAPSERVER_URL = None |
|
self.assertEqual("https://swaps.electrum.org/api", config.SWAPSERVER_URL) |
|
|
|
constants.set_testnet() |
|
try: |
|
self.assertEqual("https://swaps.electrum.org/testnet", config.SWAPSERVER_URL) |
|
finally: |
|
constants.set_mainnet() |
|
|
|
def test_configvars_convert_getter(self): |
|
config = SimpleConfig(self.options) |
|
self.assertEqual(None, config.NETWORK_PROXY) |
|
config.user_config[config.cv.NETWORK_PROXY.key()] = None |
|
self.assertEqual("none", config.NETWORK_PROXY) |
|
config.NETWORK_PROXY = None |
|
self.assertEqual(None, config.NETWORK_PROXY) |
|
|
|
def test_configvars_is_set(self): |
|
config = SimpleConfig(self.options) |
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
self.assertFalse(config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.is_set()) |
|
|
|
config.NETWORK_MAX_INCOMING_MSG_SIZE = 5_555_555 |
|
self.assertTrue(config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.is_set()) |
|
|
|
config.NETWORK_MAX_INCOMING_MSG_SIZE = None |
|
self.assertFalse(config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.is_set()) |
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
|
|
config.NETWORK_MAX_INCOMING_MSG_SIZE = MAX_MSG_SIZE_DEFAULT |
|
self.assertTrue(config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.is_set()) |
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
|
|
def test_configvars_is_modifiable(self): |
|
config = SimpleConfig({**self.options, "server": "example.com:443:s"}) |
|
|
|
self.assertFalse(config.is_modifiable("server")) |
|
self.assertFalse(config.cv.NETWORK_SERVER.is_modifiable()) |
|
|
|
config.NETWORK_SERVER = "other-example.com:80:t" |
|
self.assertEqual("example.com:443:s", config.NETWORK_SERVER) |
|
|
|
self.assertEqual(MAX_MSG_SIZE_DEFAULT, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
self.assertTrue(config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.is_modifiable()) |
|
config.NETWORK_MAX_INCOMING_MSG_SIZE = 5_555_555 |
|
self.assertEqual(5_555_555, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
|
|
config.make_key_not_modifiable(config.cv.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
self.assertFalse(config.cv.NETWORK_MAX_INCOMING_MSG_SIZE.is_modifiable()) |
|
config.NETWORK_MAX_INCOMING_MSG_SIZE = 2_222_222 |
|
self.assertEqual(5_555_555, config.NETWORK_MAX_INCOMING_MSG_SIZE) |
|
|
|
def test_configvars_from_key(self): |
|
config = SimpleConfig(self.options) |
|
self.assertEqual(config.cv.NETWORK_SERVER, config.cv.from_key("server")) |
|
with self.assertRaises(KeyError): |
|
config.cv.from_key("server333") |
|
|
|
def test_depth_target_to_fee(self): |
|
config = SimpleConfig(self.options) |
|
config.mempool_fees = [[49, 100110], [10, 121301], [6, 153731], [5, 125872], [1, 36488810]] |
|
self.assertEqual( 2 * 1000, config.depth_target_to_fee(1000000)) |
|
self.assertEqual( 6 * 1000, config.depth_target_to_fee( 500000)) |
|
self.assertEqual( 7 * 1000, config.depth_target_to_fee( 250000)) |
|
self.assertEqual(11 * 1000, config.depth_target_to_fee( 200000)) |
|
self.assertEqual(50 * 1000, config.depth_target_to_fee( 100000)) |
|
config.mempool_fees = [] |
|
self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 5)) |
|
self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 6)) |
|
self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 7)) |
|
config.mempool_fees = [[1, 36488810]] |
|
self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 5)) |
|
self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 6)) |
|
self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 7)) |
|
self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 8)) |
|
config.mempool_fees = [[5, 125872], [1, 36488810]] |
|
self.assertEqual( 6 * 1000, config.depth_target_to_fee(10 ** 5)) |
|
self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 6)) |
|
self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 7)) |
|
self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 8)) |
|
config.mempool_fees = [] |
|
self.assertEqual(1 * 1000, config.depth_target_to_fee(10 ** 5)) |
|
config.mempool_fees = None |
|
self.assertEqual(None, config.depth_target_to_fee(10 ** 5)) |
|
|
|
def test_fee_to_depth(self): |
|
config = SimpleConfig(self.options) |
|
config.mempool_fees = [[49, 100000], [10, 120000], [6, 150000], [5, 125000], [1, 36000000]] |
|
self.assertEqual(100000, config.fee_to_depth(500)) |
|
self.assertEqual(100000, config.fee_to_depth(50)) |
|
self.assertEqual(100000, config.fee_to_depth(49)) |
|
self.assertEqual(220000, config.fee_to_depth(48)) |
|
self.assertEqual(220000, config.fee_to_depth(10)) |
|
self.assertEqual(370000, config.fee_to_depth(9)) |
|
self.assertEqual(370000, config.fee_to_depth(6.5)) |
|
self.assertEqual(370000, config.fee_to_depth(6)) |
|
self.assertEqual(495000, config.fee_to_depth(5.5)) |
|
self.assertEqual(36495000, config.fee_to_depth(0.5)) |
|
|
|
|
|
class TestUserConfig(ElectrumTestCase): |
|
|
|
def setUp(self): |
|
super(TestUserConfig, self).setUp() |
|
self._saved_stdout = sys.stdout |
|
self._stdout_buffer = StringIO() |
|
sys.stdout = self._stdout_buffer |
|
|
|
self.user_dir = tempfile.mkdtemp() |
|
|
|
def tearDown(self): |
|
super(TestUserConfig, self).tearDown() |
|
shutil.rmtree(self.user_dir) |
|
sys.stdout = self._saved_stdout |
|
|
|
def test_no_path_means_no_result(self): |
|
result = read_user_config(None) |
|
self.assertEqual({}, result) |
|
|
|
def test_path_without_config_file(self): |
|
"""We pass a path but if does not contain a "config" file.""" |
|
result = read_user_config(self.user_dir) |
|
self.assertEqual({}, result) |
|
|
|
def test_path_with_reprd_object(self): |
|
|
|
class something(object): |
|
pass |
|
|
|
thefile = os.path.join(self.user_dir, "config") |
|
payload = something() |
|
with open(thefile, "w") as f: |
|
f.write(repr(payload)) |
|
|
|
result = read_user_config(self.user_dir) |
|
self.assertEqual({}, result)
|
|
|