test_simple_config.py (8632B)
1 import ast 2 import sys 3 import os 4 import tempfile 5 import shutil 6 7 from io import StringIO 8 from electrum.simple_config import (SimpleConfig, read_user_config) 9 10 from . import ElectrumTestCase 11 12 13 class Test_SimpleConfig(ElectrumTestCase): 14 15 def setUp(self): 16 super(Test_SimpleConfig, self).setUp() 17 # make sure "read_user_config" and "user_dir" return a temporary directory. 18 self.electrum_dir = tempfile.mkdtemp() 19 # Do the same for the user dir to avoid overwriting the real configuration 20 # for development machines with electrum installed :) 21 self.user_dir = tempfile.mkdtemp() 22 23 self.options = {"electrum_path": self.electrum_dir} 24 self._saved_stdout = sys.stdout 25 self._stdout_buffer = StringIO() 26 sys.stdout = self._stdout_buffer 27 28 def tearDown(self): 29 super(Test_SimpleConfig, self).tearDown() 30 # Remove the temporary directory after each test (to make sure we don't 31 # pollute /tmp for nothing. 32 shutil.rmtree(self.electrum_dir) 33 shutil.rmtree(self.user_dir) 34 35 # Restore the "real" stdout 36 sys.stdout = self._saved_stdout 37 38 def test_simple_config_key_rename(self): 39 """auto_cycle was renamed auto_connect""" 40 fake_read_user = lambda _: {"auto_cycle": True} 41 read_user_dir = lambda : self.user_dir 42 config = SimpleConfig(options=self.options, 43 read_user_config_function=fake_read_user, 44 read_user_dir_function=read_user_dir) 45 self.assertEqual(config.get("auto_connect"), True) 46 self.assertEqual(config.get("auto_cycle"), None) 47 fake_read_user = lambda _: {"auto_connect": False, "auto_cycle": True} 48 config = SimpleConfig(options=self.options, 49 read_user_config_function=fake_read_user, 50 read_user_dir_function=read_user_dir) 51 self.assertEqual(config.get("auto_connect"), False) 52 self.assertEqual(config.get("auto_cycle"), None) 53 54 def test_simple_config_command_line_overrides_everything(self): 55 """Options passed by command line override all other configuration 56 sources""" 57 fake_read_user = lambda _: {"electrum_path": "b"} 58 read_user_dir = lambda : self.user_dir 59 config = SimpleConfig(options=self.options, 60 read_user_config_function=fake_read_user, 61 read_user_dir_function=read_user_dir) 62 self.assertEqual(self.options.get("electrum_path"), 63 config.get("electrum_path")) 64 65 def test_simple_config_user_config_is_used_if_others_arent_specified(self): 66 """If no system-wide configuration and no command-line options are 67 specified, the user configuration is used instead.""" 68 fake_read_user = lambda _: {"electrum_path": self.electrum_dir} 69 read_user_dir = lambda : self.user_dir 70 config = SimpleConfig(options={}, 71 read_user_config_function=fake_read_user, 72 read_user_dir_function=read_user_dir) 73 self.assertEqual(self.options.get("electrum_path"), 74 config.get("electrum_path")) 75 76 def test_cannot_set_options_passed_by_command_line(self): 77 fake_read_user = lambda _: {"electrum_path": "b"} 78 read_user_dir = lambda : self.user_dir 79 config = SimpleConfig(options=self.options, 80 read_user_config_function=fake_read_user, 81 read_user_dir_function=read_user_dir) 82 config.set_key("electrum_path", "c") 83 self.assertEqual(self.options.get("electrum_path"), 84 config.get("electrum_path")) 85 86 def test_can_set_options_set_in_user_config(self): 87 another_path = tempfile.mkdtemp() 88 fake_read_user = lambda _: {"electrum_path": self.electrum_dir} 89 read_user_dir = lambda : self.user_dir 90 config = SimpleConfig(options={}, 91 read_user_config_function=fake_read_user, 92 read_user_dir_function=read_user_dir) 93 config.set_key("electrum_path", another_path) 94 self.assertEqual(another_path, config.get("electrum_path")) 95 96 def test_user_config_is_not_written_with_read_only_config(self): 97 """The user config does not contain command-line options when saved.""" 98 fake_read_user = lambda _: {"something": "a"} 99 read_user_dir = lambda : self.user_dir 100 self.options.update({"something": "c"}) 101 config = SimpleConfig(options=self.options, 102 read_user_config_function=fake_read_user, 103 read_user_dir_function=read_user_dir) 104 config.save_user_config() 105 contents = None 106 with open(os.path.join(self.electrum_dir, "config"), "r") as f: 107 contents = f.read() 108 result = ast.literal_eval(contents) 109 result.pop('config_version', None) 110 self.assertEqual({"something": "a"}, result) 111 112 def test_depth_target_to_fee(self): 113 config = SimpleConfig(self.options) 114 config.mempool_fees = [[49, 100110], [10, 121301], [6, 153731], [5, 125872], [1, 36488810]] 115 self.assertEqual( 2 * 1000, config.depth_target_to_fee(1000000)) 116 self.assertEqual( 6 * 1000, config.depth_target_to_fee( 500000)) 117 self.assertEqual( 7 * 1000, config.depth_target_to_fee( 250000)) 118 self.assertEqual(11 * 1000, config.depth_target_to_fee( 200000)) 119 self.assertEqual(50 * 1000, config.depth_target_to_fee( 100000)) 120 config.mempool_fees = [] 121 self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 5)) 122 self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 6)) 123 self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 7)) 124 config.mempool_fees = [[1, 36488810]] 125 self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 5)) 126 self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 6)) 127 self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 7)) 128 self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 8)) 129 config.mempool_fees = [[5, 125872], [1, 36488810]] 130 self.assertEqual( 6 * 1000, config.depth_target_to_fee(10 ** 5)) 131 self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 6)) 132 self.assertEqual( 2 * 1000, config.depth_target_to_fee(10 ** 7)) 133 self.assertEqual( 1 * 1000, config.depth_target_to_fee(10 ** 8)) 134 config.mempool_fees = [] 135 self.assertEqual(1 * 1000, config.depth_target_to_fee(10 ** 5)) 136 config.mempool_fees = None 137 self.assertEqual(None, config.depth_target_to_fee(10 ** 5)) 138 139 def test_fee_to_depth(self): 140 config = SimpleConfig(self.options) 141 config.mempool_fees = [[49, 100000], [10, 120000], [6, 150000], [5, 125000], [1, 36000000]] 142 self.assertEqual(100000, config.fee_to_depth(500)) 143 self.assertEqual(100000, config.fee_to_depth(50)) 144 self.assertEqual(100000, config.fee_to_depth(49)) 145 self.assertEqual(220000, config.fee_to_depth(48)) 146 self.assertEqual(220000, config.fee_to_depth(10)) 147 self.assertEqual(370000, config.fee_to_depth(9)) 148 self.assertEqual(370000, config.fee_to_depth(6.5)) 149 self.assertEqual(370000, config.fee_to_depth(6)) 150 self.assertEqual(495000, config.fee_to_depth(5.5)) 151 self.assertEqual(36495000, config.fee_to_depth(0.5)) 152 153 154 class TestUserConfig(ElectrumTestCase): 155 156 def setUp(self): 157 super(TestUserConfig, self).setUp() 158 self._saved_stdout = sys.stdout 159 self._stdout_buffer = StringIO() 160 sys.stdout = self._stdout_buffer 161 162 self.user_dir = tempfile.mkdtemp() 163 164 def tearDown(self): 165 super(TestUserConfig, self).tearDown() 166 shutil.rmtree(self.user_dir) 167 sys.stdout = self._saved_stdout 168 169 def test_no_path_means_no_result(self): 170 result = read_user_config(None) 171 self.assertEqual({}, result) 172 173 def test_path_without_config_file(self): 174 """We pass a path but if does not contain a "config" file.""" 175 result = read_user_config(self.user_dir) 176 self.assertEqual({}, result) 177 178 def test_path_with_reprd_object(self): 179 180 class something(object): 181 pass 182 183 thefile = os.path.join(self.user_dir, "config") 184 payload = something() 185 with open(thefile, "w") as f: 186 f.write(repr(payload)) 187 188 result = read_user_config(self.user_dir) 189 self.assertEqual({}, result)