lib/tests/test_simple_config.py

   1 import sys
   2 import unittest
   3 import tempfile
   4 import shutil
   5
   6 from StringIO import StringIO
   7 from lib.simple_config import SimpleConfig
   8
   9
  10 class Test_SimpleConfig(unittest.TestCase):
  11
  12     def setUp(self):
  13         super(Test_SimpleConfig, self).setUp()
  14         # make sure "read_user_config" and "user_dir" return a temporary directory.
  15         self.electrum_dir = tempfile.mkdtemp()
  16         # Do the same for the user dir to avoid overwriting the real configuration
  17         # for development machines with electrum installed :)
  18         self.user_dir = tempfile.mkdtemp()
  19
  20         self.options = {"electrum_path": self.electrum_dir}
  21         self._saved_stdout = sys.stdout
  22         self._stdout_buffer = StringIO()
  23         sys.stdout = self._stdout_buffer
  24
  25     def tearDown(self):
  26         super(Test_SimpleConfig, self).tearDown()
  27         # Remove the temporary directory after each test (to make sure we don't
  28         # pollute /tmp for nothing.
  29         shutil.rmtree(self.electrum_dir)
  30         shutil.rmtree(self.user_dir)
  31
  32         # Restore the "real" stdout
  33         sys.stdout = self._saved_stdout
  34
  35     def test_simple_config_command_line_overrides_everything(self):
  36         """Options passed by command line override all other configuration
  37         sources"""
  38         fake_read_system = lambda : {"electrum_path": "a"}
  39         fake_read_user = lambda _: {"electrum_path": "b"}
  40         read_user_dir = lambda : self.user_dir
  41         config = SimpleConfig(options=self.options,
  42                               read_system_config_function=fake_read_system,
  43                               read_user_config_function=fake_read_user,
  44                               read_user_dir_function=read_user_dir)
  45         self.assertEqual(self.options.get("electrum_path"),
  46                          config.get("electrum_path"))
  47
  48     def test_simple_config_system_config_overrides_user_config(self):
  49         """Options passed in system config override user config."""
  50         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
  51         fake_read_user = lambda _: {"electrum_path": "b"}
  52         read_user_dir = lambda : self.user_dir
  53         config = SimpleConfig(options=None,
  54                               read_system_config_function=fake_read_system,
  55                               read_user_config_function=fake_read_user,
  56                               read_user_dir_function=read_user_dir)
  57         self.assertEqual(self.options.get("electrum_path"),
  58                          config.get("electrum_path"))
  59
  60     def test_simple_config_system_config_ignored_if_portable(self):
  61         """If electrum is started with the "portable" flag, system
  62         configuration is completely ignored."""
  63         another_path = tempfile.mkdtemp()
  64         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
  65         fake_read_user = lambda _: {"electrum_path": another_path}
  66         read_user_dir = lambda : self.user_dir
  67         config = SimpleConfig(options={"portable": True},
  68                               read_system_config_function=fake_read_system,
  69                               read_user_config_function=fake_read_user,
  70                               read_user_dir_function=read_user_dir)
  71         self.assertEqual(another_path, config.get("electrum_path"))
  72
  73     def test_simple_config_user_config_is_used_if_others_arent_specified(self):
  74         """If no system-wide configuration and no command-line options are
  75         specified, the user configuration is used instead."""
  76         fake_read_system = lambda : {}
  77         fake_read_user = lambda _: {"electrum_path": self.electrum_dir}
  78         read_user_dir = lambda : self.user_dir
  79         config = SimpleConfig(options=None,
  80                               read_system_config_function=fake_read_system,
  81                               read_user_config_function=fake_read_user,
  82                               read_user_dir_function=read_user_dir)
  83         self.assertEqual(self.options.get("electrum_path"),
  84                          config.get("electrum_path"))
  85
  86     def test_cannot_set_options_passed_by_command_line(self):
  87         fake_read_system = lambda : {}
  88         fake_read_user = lambda _: {"electrum_path": "b"}
  89         read_user_dir = lambda : self.user_dir
  90         config = SimpleConfig(options=self.options,
  91                               read_system_config_function=fake_read_system,
  92                               read_user_config_function=fake_read_user,
  93                               read_user_dir_function=read_user_dir)
  94         config.set_key("electrum_path", "c")
  95         self.assertEqual(self.options.get("electrum_path"),
  96                          config.get("electrum_path"))
  97
  98     def test_cannot_set_options_from_system_config(self):
  99         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
 100         fake_read_user = lambda _: {}
 101         read_user_dir = lambda : self.user_dir
 102         config = SimpleConfig(options={},
 103                               read_system_config_function=fake_read_system,
 104                               read_user_config_function=fake_read_user,
 105                               read_user_dir_function=read_user_dir)
 106         config.set_key("electrum_path", "c")
 107         self.assertEqual(self.options.get("electrum_path"),
 108                          config.get("electrum_path"))
 109
 110     def test_can_set_options_set_in_user_config(self):
 111         another_path = tempfile.mkdtemp()
 112         fake_read_system = lambda : {}
 113         fake_read_user = lambda _: {"electrum_path": self.electrum_dir}
 114         read_user_dir = lambda : self.user_dir
 115         config = SimpleConfig(options={},
 116                               read_system_config_function=fake_read_system,
 117                               read_user_config_function=fake_read_user,
 118                               read_user_dir_function=read_user_dir)
 119         config.set_key("electrum_path", another_path)
 120         self.assertEqual(another_path, config.get("electrum_path"))
 121
 122     def test_can_set_options_from_system_config_if_portable(self):
 123         """If the "portable" flag is set, the user can overwrite system
 124         configuration options."""
 125         another_path = tempfile.mkdtemp()
 126         fake_read_system = lambda : {"electrum_path": self.electrum_dir}
 127         fake_read_user = lambda _: {}
 128         read_user_dir = lambda : self.user_dir
 129         config = SimpleConfig(options={"portable": True},
 130                               read_system_config_function=fake_read_system,
 131                               read_user_config_function=fake_read_user,
 132                               read_user_dir_function=read_user_dir)
 133         config.set_key("electrum_path", another_path)
 134         self.assertEqual(another_path, config.get("electrum_path"))