lib/tests/test_simple_config.py

   1 import sys
   2 import os
   3 import unittest
   4 import tempfile
   5 import shutil
   6
   7 from StringIO import StringIO
   8 from lib.simple_config import SimpleConfig, read_system_config
   9
  10
  11 class Test_SimpleConfig(unittest.TestCase):
  12
  13     def setUp(self):
  14         super(Test_SimpleConfig, self).setUp()
  15         # make sure "read_user_config" and "user_dir" return a temporary directory.
  16         self.electrum_dir = tempfile.mkdtemp()
  17         # Do the same for the user dir to avoid overwriting the real configuration
  18         # for development machines with electrum installed :)
  19         self.user_dir = tempfile.mkdtemp()
  20
  21         self.options = {"electrum_path": self.electrum_dir}
  22         self._saved_stdout = sys.stdout
  23         self._stdout_buffer = StringIO()
  24         sys.stdout = self._stdout_buffer
  25
  26     def tearDown(self):
  27         super(Test_SimpleConfig, self).tearDown()
  28         # Remove the temporary directory after each test (to make sure we don't
  29         # pollute /tmp for nothing.
  30         shutil.rmtree(self.electrum_dir)
  31         shutil.rmtree(self.user_dir)
  32
  33         # Restore the "real" stdout
  34         sys.stdout = self._saved_stdout
  35
  36     def test_simple_config_command_line_overrides_everything(self):
  37         """Options passed by command line override all other configuration
  38         sources"""
  39         fake_read_system = lambda : {"electrum_path": "a"}
  40         fake_read_user = lambda _: {"electrum_path": "b"}
  41         read_user_dir = lambda : self.user_dir
  42         config = SimpleConfig(options=self.options,
  43                               read_system_config_function=fake_read_system,
  44                               read_user_config_function=fake_read_user,
  45                               read_user_dir_function=read_user_dir)
  46         self.assertEqual(self.options.get("electrum_path"),
  47                          config.get("electrum_path"))
  48
  49     def test_simple_config_system_config_overrides_user_config(self):
  50         """Options passed in system config override user config."""
  51         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
  52         fake_read_user = lambda _: {"electrum_path": "b"}
  53         read_user_dir = lambda : self.user_dir
  54         config = SimpleConfig(options=None,
  55                               read_system_config_function=fake_read_system,
  56                               read_user_config_function=fake_read_user,
  57                               read_user_dir_function=read_user_dir)
  58         self.assertEqual(self.options.get("electrum_path"),
  59                          config.get("electrum_path"))
  60
  61     def test_simple_config_system_config_ignored_if_portable(self):
  62         """If electrum is started with the "portable" flag, system
  63         configuration is completely ignored."""
  64         another_path = tempfile.mkdtemp()
  65         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
  66         fake_read_user = lambda _: {"electrum_path": another_path}
  67         read_user_dir = lambda : self.user_dir
  68         config = SimpleConfig(options={"portable": True},
  69                               read_system_config_function=fake_read_system,
  70                               read_user_config_function=fake_read_user,
  71                               read_user_dir_function=read_user_dir)
  72         self.assertEqual(another_path, config.get("electrum_path"))
  73
  74     def test_simple_config_user_config_is_used_if_others_arent_specified(self):
  75         """If no system-wide configuration and no command-line options are
  76         specified, the user configuration is used instead."""
  77         fake_read_system = lambda : {}
  78         fake_read_user = lambda _: {"electrum_path": self.electrum_dir}
  79         read_user_dir = lambda : self.user_dir
  80         config = SimpleConfig(options=None,
  81                               read_system_config_function=fake_read_system,
  82                               read_user_config_function=fake_read_user,
  83                               read_user_dir_function=read_user_dir)
  84         self.assertEqual(self.options.get("electrum_path"),
  85                          config.get("electrum_path"))
  86
  87     def test_cannot_set_options_passed_by_command_line(self):
  88         fake_read_system = lambda : {}
  89         fake_read_user = lambda _: {"electrum_path": "b"}
  90         read_user_dir = lambda : self.user_dir
  91         config = SimpleConfig(options=self.options,
  92                               read_system_config_function=fake_read_system,
  93                               read_user_config_function=fake_read_user,
  94                               read_user_dir_function=read_user_dir)
  95         config.set_key("electrum_path", "c")
  96         self.assertEqual(self.options.get("electrum_path"),
  97                          config.get("electrum_path"))
  98
  99     def test_cannot_set_options_from_system_config(self):
 100         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
 101         fake_read_user = lambda _: {}
 102         read_user_dir = lambda : self.user_dir
 103         config = SimpleConfig(options={},
 104                               read_system_config_function=fake_read_system,
 105                               read_user_config_function=fake_read_user,
 106                               read_user_dir_function=read_user_dir)
 107         config.set_key("electrum_path", "c")
 108         self.assertEqual(self.options.get("electrum_path"),
 109                          config.get("electrum_path"))
 110
 111     def test_can_set_options_set_in_user_config(self):
 112         another_path = tempfile.mkdtemp()
 113         fake_read_system = lambda : {}
 114         fake_read_user = lambda _: {"electrum_path": self.electrum_dir}
 115         read_user_dir = lambda : self.user_dir
 116         config = SimpleConfig(options={},
 117                               read_system_config_function=fake_read_system,
 118                               read_user_config_function=fake_read_user,
 119                               read_user_dir_function=read_user_dir)
 120         config.set_key("electrum_path", another_path)
 121         self.assertEqual(another_path, config.get("electrum_path"))
 122
 123     def test_can_set_options_from_system_config_if_portable(self):
 124         """If the "portable" flag is set, the user can overwrite system
 125         configuration options."""
 126         another_path = tempfile.mkdtemp()
 127         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
 128         fake_read_user = lambda _: {}
 129         read_user_dir = lambda : self.user_dir
 130         config = SimpleConfig(options={"portable": True},
 131                               read_system_config_function=fake_read_system,
 132                               read_user_config_function=fake_read_user,
 133                               read_user_dir_function=read_user_dir)
 134         config.set_key("electrum_path", another_path)
 135         self.assertEqual(another_path, config.get("electrum_path"))
 136
 137
 138 class TestSystemConfig(unittest.TestCase):
 139
 140     sample_conf = """
 141 [client]
 142 gap_limit = 5
 143
 144 [something_else]
 145 everything = 42
 146 """
 147
 148     def setUp(self):
 149         super(TestSystemConfig, self).setUp()
 150         self.thefile = tempfile.mkstemp(suffix=".electrum.test.conf")[1]
 151
 152     def tearDown(self):
 153         os.remove(self.thefile)
 154
 155     def test_read_system_config_file_does_not_exist(self):
 156         somefile = "/foo/I/do/not/exist/electrum.conf"
 157         result = read_system_config(somefile)
 158         self.assertEqual({}, result)
 159
 160     def test_read_system_config_file_returns_file_options(self):
 161         with open(self.thefile, "w") as f:
 162             f.write(self.sample_conf)
 163
 164         result = read_system_config(self.thefile)
 165         self.assertEqual({"gap_limit": "5"}, result)
 166
 167     def test_read_system_config_file_no_sections(self):
 168
 169         with open(self.thefile, "w") as f:
 170             f.write("gap_limit = 5")  # The file has no sections at all
 171
 172         result = read_system_config(self.thefile)
 173         self.assertEqual({}, result)