lib/tests/test_simple_config.py

   1 import ast
   2 import sys
   3 import os
   4 import unittest
   5 import tempfile
   6 import shutil
   7
   8 from StringIO import StringIO
   9 from lib.simple_config import (SimpleConfig, read_system_config,
  10                                read_user_config)
  11
  12
  13 class Test_SimpleConfig(unittest.TestCase):
  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_command_line_overrides_everything(self):
  39         """Options passed by command line override all other configuration
  40         sources"""
  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"))
  50
  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"))
  62
  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"))
  75
  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"))
  88
  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"))
 100
 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"))
 112
 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"))
 124
 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"))
 138
 139     def test_user_config_is_not_written_with_system_config(self):
 140         """The user config does not contain command-line options when saved."""
 141         fake_read_system = lambda : {"something": "b"}
 142         fake_read_user = lambda _: {"something": "a"}
 143         read_user_dir = lambda : self.user_dir
 144         self.options.update({"something": "c"})
 145         config = SimpleConfig(options=self.options,
 146                               read_system_config_function=fake_read_system,
 147                               read_user_config_function=fake_read_user,
 148                               read_user_dir_function=read_user_dir)
 149         config.save_user_config()
 150         contents = None
 151         with open(os.path.join(self.electrum_dir, "config"), "r") as f:
 152             contents = f.read()
 153         result = ast.literal_eval(contents)
 154         self.assertEqual({"something": "a"}, result)
 155
 156
 157 class TestSystemConfig(unittest.TestCase):
 158
 159     sample_conf = """
 160 [client]
 161 gap_limit = 5
 162
 163 [something_else]
 164 everything = 42
 165 """
 166
 167     def setUp(self):
 168         super(TestSystemConfig, self).setUp()
 169         self.thefile = tempfile.mkstemp(suffix=".electrum.test.conf")[1]
 170
 171     def tearDown(self):
 172         super(TestSystemConfig, self).tearDown()
 173         os.remove(self.thefile)
 174
 175     def test_read_system_config_file_does_not_exist(self):
 176         somefile = "/foo/I/do/not/exist/electrum.conf"
 177         result = read_system_config(somefile)
 178         self.assertEqual({}, result)
 179
 180     def test_read_system_config_file_returns_file_options(self):
 181         with open(self.thefile, "w") as f:
 182             f.write(self.sample_conf)
 183
 184         result = read_system_config(self.thefile)
 185         self.assertEqual({"gap_limit": "5"}, result)
 186
 187     def test_read_system_config_file_no_sections(self):
 188
 189         with open(self.thefile, "w") as f:
 190             f.write("gap_limit = 5")  # The file has no sections at all
 191
 192         result = read_system_config(self.thefile)
 193         self.assertEqual({}, result)
 194
 195
 196 class TestUserConfig(unittest.TestCase):
 197
 198     def setUp(self):
 199         super(TestUserConfig, self).setUp()
 200         self._saved_stdout = sys.stdout
 201         self._stdout_buffer = StringIO()
 202         sys.stdout = self._stdout_buffer
 203
 204         self.user_dir = tempfile.mkdtemp()
 205
 206     def tearDown(self):
 207         super(TestUserConfig, self).tearDown()
 208         shutil.rmtree(self.user_dir)
 209         sys.stdout = self._saved_stdout
 210
 211     def test_no_path_means_no_result(self):
 212        result = read_user_config(None)
 213        self.assertEqual({}, result)
 214
 215     def test_path_with_reprd_dict(self):
 216         thefile = os.path.join(self.user_dir, "config")
 217         payload = {"gap_limit": 5}
 218         with open(thefile, "w") as f:
 219             f.write(repr(payload))
 220
 221         result = read_user_config(self.user_dir)
 222         self.assertEqual(payload, result)
 223
 224     def test_path_without_config_file(self):
 225         """We pass a path but if does not contain a "config" file."""
 226         result = read_user_config(self.user_dir)
 227         self.assertEqual({}, result)
 228
 229     def test_path_with_reprd_object(self):
 230
 231         class something(object):
 232             pass
 233
 234         thefile = os.path.join(self.user_dir, "config")
 235         payload = something()
 236         with open(thefile, "w") as f:
 237             f.write(repr(payload))
 238
 239         result = read_user_config(self.user_dir)
 240         self.assertEqual({}, result)