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_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()
 151         contents = None
 152         with open(os.path.join(self.electrum_dir, "config"), "r") as f:
 153             contents = f.read()
 154         result = ast.literal_eval(contents)
 155         self.assertEqual({"something": "a"}, result)
 156
 157
 158 class TestSystemConfig(unittest.TestCase):
 159
 160     sample_conf = """
 161 [client]
 162 gap_limit = 5
 163
 164 [something_else]
 165 everything = 42
 166 """
 167
 168     def setUp(self):
 169         super(TestSystemConfig, self).setUp()
 170         self.thefile = tempfile.mkstemp(suffix=".electrum.test.conf")[1]
 171
 172     def tearDown(self):
 173         super(TestSystemConfig, self).tearDown()
 174         os.remove(self.thefile)
 175
 176     def test_read_system_config_file_does_not_exist(self):
 177         somefile = "/foo/I/do/not/exist/electrum.conf"
 178         result = read_system_config(somefile)
 179         self.assertEqual({}, result)
 180
 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)
 184
 185         result = read_system_config(self.thefile)
 186         self.assertEqual({"gap_limit": "5"}, result)
 187
 188     def test_read_system_config_file_no_sections(self):
 189
 190         with open(self.thefile, "w") as f:
 191             f.write("gap_limit = 5")  # The file has no sections at all
 192
 193         result = read_system_config(self.thefile)
 194         self.assertEqual({}, result)
 195
 196
 197 class TestUserConfig(unittest.TestCase):
 198
 199     def setUp(self):
 200         super(TestUserConfig, self).setUp()
 201         self._saved_stdout = sys.stdout
 202         self._stdout_buffer = StringIO()
 203         sys.stdout = self._stdout_buffer
 204
 205         self.user_dir = tempfile.mkdtemp()
 206
 207     def tearDown(self):
 208         super(TestUserConfig, self).tearDown()
 209         shutil.rmtree(self.user_dir)
 210         sys.stdout = self._saved_stdout
 211
 212     def test_no_path_means_no_result(self):
 213        result = read_user_config(None)
 214        self.assertEqual({}, result)
 215
 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))
 221
 222         result = read_user_config(self.user_dir)
 223         self.assertEqual(payload, result)
 224
 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)
 229
 230     def test_path_with_reprd_object(self):
 231
 232         class something(object):
 233             pass
 234
 235         thefile = os.path.join(self.user_dir, "config")
 236         payload = something()
 237         with open(thefile, "w") as f:
 238             f.write(repr(payload))
 239
 240         result = read_user_config(self.user_dir)
 241         self.assertEqual({}, result)