8 from StringIO import StringIO
9 from lib.simple_config import (SimpleConfig, read_system_config,
13 class Test_SimpleConfig(unittest.TestCase):
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()
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
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)
35 # Restore the "real" stdout
36 sys.stdout = self._saved_stdout
38 def test_simple_config_command_line_overrides_everything(self):
39 """Options passed by command line override all other configuration
41 fake_read_system = lambda : {"electrum_path": "a"}
42 fake_read_user = lambda _: {"electrum_path": "b"}
43 read_user_dir = lambda : self.user_dir
44 config = SimpleConfig(options=self.options,
45 read_system_config_function=fake_read_system,
46 read_user_config_function=fake_read_user,
47 read_user_dir_function=read_user_dir)
48 self.assertEqual(self.options.get("electrum_path"),
49 config.get("electrum_path"))
51 def test_simple_config_system_config_overrides_user_config(self):
52 """Options passed in system config override user config."""
53 fake_read_system = lambda : {"electrum_path": self.electrum_dir}
54 fake_read_user = lambda _: {"electrum_path": "b"}
55 read_user_dir = lambda : self.user_dir
56 config = SimpleConfig(options=None,
57 read_system_config_function=fake_read_system,
58 read_user_config_function=fake_read_user,
59 read_user_dir_function=read_user_dir)
60 self.assertEqual(self.options.get("electrum_path"),
61 config.get("electrum_path"))
63 def test_simple_config_system_config_ignored_if_portable(self):
64 """If electrum is started with the "portable" flag, system
65 configuration is completely ignored."""
66 another_path = tempfile.mkdtemp()
67 fake_read_system = lambda : {"electrum_path": self.electrum_dir}
68 fake_read_user = lambda _: {"electrum_path": another_path}
69 read_user_dir = lambda : self.user_dir
70 config = SimpleConfig(options={"portable": True},
71 read_system_config_function=fake_read_system,
72 read_user_config_function=fake_read_user,
73 read_user_dir_function=read_user_dir)
74 self.assertEqual(another_path, config.get("electrum_path"))
76 def test_simple_config_user_config_is_used_if_others_arent_specified(self):
77 """If no system-wide configuration and no command-line options are
78 specified, the user configuration is used instead."""
79 fake_read_system = lambda : {}
80 fake_read_user = lambda _: {"electrum_path": self.electrum_dir}
81 read_user_dir = lambda : self.user_dir
82 config = SimpleConfig(options=None,
83 read_system_config_function=fake_read_system,
84 read_user_config_function=fake_read_user,
85 read_user_dir_function=read_user_dir)
86 self.assertEqual(self.options.get("electrum_path"),
87 config.get("electrum_path"))
89 def test_cannot_set_options_passed_by_command_line(self):
90 fake_read_system = lambda : {}
91 fake_read_user = lambda _: {"electrum_path": "b"}
92 read_user_dir = lambda : self.user_dir
93 config = SimpleConfig(options=self.options,
94 read_system_config_function=fake_read_system,
95 read_user_config_function=fake_read_user,
96 read_user_dir_function=read_user_dir)
97 config.set_key("electrum_path", "c")
98 self.assertEqual(self.options.get("electrum_path"),
99 config.get("electrum_path"))
101 def test_cannot_set_options_from_system_config(self):
102 fake_read_system = lambda : {"electrum_path": self.electrum_dir}
103 fake_read_user = lambda _: {}
104 read_user_dir = lambda : self.user_dir
105 config = SimpleConfig(options={},
106 read_system_config_function=fake_read_system,
107 read_user_config_function=fake_read_user,
108 read_user_dir_function=read_user_dir)
109 config.set_key("electrum_path", "c")
110 self.assertEqual(self.options.get("electrum_path"),
111 config.get("electrum_path"))
113 def test_can_set_options_set_in_user_config(self):
114 another_path = tempfile.mkdtemp()
115 fake_read_system = lambda : {}
116 fake_read_user = lambda _: {"electrum_path": self.electrum_dir}
117 read_user_dir = lambda : self.user_dir
118 config = SimpleConfig(options={},
119 read_system_config_function=fake_read_system,
120 read_user_config_function=fake_read_user,
121 read_user_dir_function=read_user_dir)
122 config.set_key("electrum_path", another_path)
123 self.assertEqual(another_path, config.get("electrum_path"))
125 def test_can_set_options_from_system_config_if_portable(self):
126 """If the "portable" flag is set, the user can overwrite system
127 configuration options."""
128 another_path = tempfile.mkdtemp()
129 fake_read_system = lambda : {"electrum_path": self.electrum_dir}
130 fake_read_user = lambda _: {}
131 read_user_dir = lambda : self.user_dir
132 config = SimpleConfig(options={"portable": True},
133 read_system_config_function=fake_read_system,
134 read_user_config_function=fake_read_user,
135 read_user_dir_function=read_user_dir)
136 config.set_key("electrum_path", another_path)
137 self.assertEqual(another_path, config.get("electrum_path"))
139 def test_user_config_is_not_written_with_read_only_config(self):
140 """The user config does not contain command-line options or system
141 options when saved."""
142 fake_read_system = lambda : {"something": "b"}
143 fake_read_user = lambda _: {"something": "a"}
144 read_user_dir = lambda : self.user_dir
145 self.options.update({"something": "c"})
146 config = SimpleConfig(options=self.options,
147 read_system_config_function=fake_read_system,
148 read_user_config_function=fake_read_user,
149 read_user_dir_function=read_user_dir)
150 config.save_user_config()
152 with open(os.path.join(self.electrum_dir, "config"), "r") as f:
154 result = ast.literal_eval(contents)
155 self.assertEqual({"something": "a"}, result)
158 class TestSystemConfig(unittest.TestCase):
169 super(TestSystemConfig, self).setUp()
170 self.thefile = tempfile.mkstemp(suffix=".electrum.test.conf")[1]
173 super(TestSystemConfig, self).tearDown()
174 os.remove(self.thefile)
176 def test_read_system_config_file_does_not_exist(self):
177 somefile = "/foo/I/do/not/exist/electrum-nvc.conf"
178 result = read_system_config(somefile)
179 self.assertEqual({}, result)
181 def test_read_system_config_file_returns_file_options(self):
182 with open(self.thefile, "w") as f:
183 f.write(self.sample_conf)
185 result = read_system_config(self.thefile)
186 self.assertEqual({"gap_limit": "5"}, result)
188 def test_read_system_config_file_no_sections(self):
190 with open(self.thefile, "w") as f:
191 f.write("gap_limit = 5") # The file has no sections at all
193 result = read_system_config(self.thefile)
194 self.assertEqual({}, result)
197 class TestUserConfig(unittest.TestCase):
200 super(TestUserConfig, self).setUp()
201 self._saved_stdout = sys.stdout
202 self._stdout_buffer = StringIO()
203 sys.stdout = self._stdout_buffer
205 self.user_dir = tempfile.mkdtemp()
208 super(TestUserConfig, self).tearDown()
209 shutil.rmtree(self.user_dir)
210 sys.stdout = self._saved_stdout
212 def test_no_path_means_no_result(self):
213 result = read_user_config(None)
214 self.assertEqual({}, result)
216 def test_path_with_reprd_dict(self):
217 thefile = os.path.join(self.user_dir, "config")
218 payload = {"gap_limit": 5}
219 with open(thefile, "w") as f:
220 f.write(repr(payload))
222 result = read_user_config(self.user_dir)
223 self.assertEqual(payload, result)
225 def test_path_without_config_file(self):
226 """We pass a path but if does not contain a "config" file."""
227 result = read_user_config(self.user_dir)
228 self.assertEqual({}, result)
230 def test_path_with_reprd_object(self):
232 class something(object):
235 thefile = os.path.join(self.user_dir, "config")
236 payload = something()
237 with open(thefile, "w") as f:
238 f.write(repr(payload))
240 result = read_user_config(self.user_dir)
241 self.assertEqual({}, result)