Python standarddir.init函数代码示例

 def test_config_none(self):
     """Test initializing with config path set to None."""
     args = types.SimpleNamespace(confdir='')
     with helpers.environ_set_temp(self.env):
         standarddir.init(args)
         config.init()
     self.assertFalse(os.listdir(self.conf_path))

 def test_cache(self):
     """Test cache dir with XDG_CACHE_HOME not set."""
     env = {'HOME': self.temp_dir, 'XDG_CACHE_HOME': None}
     with helpers.environ_set_temp(env):
         standarddir.init(None)
         expected = os.path.join(self.temp_dir, '.cache', 'qutebrowser')
         self.assertEqual(standarddir.cache(), expected)

 def test_config(self, monkeypatch, tmpdir):
     """Test config dir with XDG_CONFIG_HOME not set."""
     monkeypatch.setenv('HOME', str(tmpdir))
     monkeypatch.delenv('XDG_CONFIG_HOME', raising=False)
     standarddir.init(None)
     expected = tmpdir / '.config' / 'qutebrowser_test'
     assert standarddir.config() == str(expected)

    def _init_modules(self):
        """Initialize all 'modules' which need to be initialized."""
        log.init.debug("Initializing readline-bridge...")
        readline_bridge = readline.ReadlineBridge()
        objreg.register('readline-bridge', readline_bridge)

        log.init.debug("Initializing directories...")
        standarddir.init()
        log.init.debug("Initializing config...")
        config.init(self._args)
        log.init.debug("Initializing crashlog...")
        self._handle_segfault()
        log.init.debug("Initializing websettings...")
        websettings.init()
        log.init.debug("Initializing quickmarks...")
        quickmark_manager = quickmarks.QuickmarkManager()
        objreg.register('quickmark-manager', quickmark_manager)
        log.init.debug("Initializing proxy...")
        proxy.init()
        log.init.debug("Initializing cookies...")
        cookie_jar = cookies.CookieJar(self)
        objreg.register('cookie-jar', cookie_jar)
        log.init.debug("Initializing cache...")
        diskcache = cache.DiskCache(self)
        objreg.register('cache', diskcache)
        log.init.debug("Initializing main window...")
        win_id = mainwindow.MainWindow.spawn(
            False if self._args.nowindow else True)
        main_window = objreg.get('main-window', scope='window', window=win_id)
        self.setActiveWindow(main_window)

 def test_basedir(self, tmpdir, typ):
     """Test --basedir."""
     expected = str(tmpdir / typ)
     args = types.SimpleNamespace(basedir=str(tmpdir))
     standarddir.init(args)
     func = getattr(standarddir, typ)
     assert func() == expected

 def test_cache(self, monkeypatch, tmpdir):
     """Test cache dir with XDG_CACHE_HOME not set."""
     monkeypatch.setenv('HOME', str(tmpdir))
     monkeypatch.delenv('XDG_CACHE_HOME', raising=False)
     standarddir.init(None)
     expected = tmpdir / '.cache' / 'qutebrowser_test'
     assert standarddir.cache() == expected

def test_init(mocker, tmpdir, args_kind):
    """Do some sanity checks for standarddir.init().

    Things like _init_cachedir_tag() are tested in more detail in other tests.
    """
    assert standarddir._locations == {}

    m_windows = mocker.patch('qutebrowser.utils.standarddir._move_windows')
    m_mac = mocker.patch('qutebrowser.utils.standarddir._move_macos')
    if args_kind == 'normal':
        args = types.SimpleNamespace(basedir=None)
    elif args_kind == 'basedir':
        args = types.SimpleNamespace(basedir=str(tmpdir))
    else:
        assert args_kind == 'none'
        args = None

    standarddir.init(args)

    assert standarddir._locations != {}
    if args_kind == 'normal':
        if sys.platform == 'darwin':
            assert not m_windows.called
            assert m_mac.called
        elif os.name == 'nt':
            assert m_windows.called
            assert not m_mac.called
        else:
            assert not m_windows.called
            assert not m_mac.called
    else:
        assert not m_windows.called
        assert not m_mac.called

 def test_data(self, monkeypatch, tmpdir):
     """Test data dir with XDG_DATA_HOME not set."""
     monkeypatch.setenv('HOME', str(tmpdir))
     monkeypatch.delenv('XDG_DATA_HOME', raising=False)
     standarddir.init(None)
     expected = tmpdir / '.local' / 'share' / 'qutebrowser_test'
     assert standarddir.data() == str(expected)

 def test_system_datadir_not_exist_linux(self, monkeypatch, tmpdir,
                                         fake_args):
     """Test that system-wide path isn't used on linux if path not exist."""
     fake_args.basedir = str(tmpdir)
     standarddir.init(fake_args)
     monkeypatch.setattr(os.path, 'exists', lambda path: False)
     assert standarddir.system_data() == standarddir.data()

 def test_system_datadir_unsupportedos(self, monkeypatch, tmpdir,
                                       fake_args):
     """Test that system-wide path is not used on non-Linux OS."""
     fake_args.basedir = str(tmpdir)
     standarddir.init(fake_args)
     monkeypatch.setattr('sys.platform', "potato")
     assert standarddir.system_data() == standarddir.data()

 def test_config_none(self, monkeypatch):
     """Test initializing with config path set to None."""
     args = types.SimpleNamespace(confdir='', datadir='', cachedir='')
     for k, v in self.env.items():
         monkeypatch.setenv(k, v)
     standarddir.init(args)
     config.init()
     assert not os.listdir(str(self.conf_path))

 def test_data(self):
     """Test data dir with XDG_DATA_HOME not set."""
     env = {'HOME': self.temp_dir, 'XDG_DATA_HOME': None}
     with helpers.environ_set_temp(env):
         standarddir.init(None)
         expected = os.path.join(self.temp_dir, '.local', 'share',
                                 'qutebrowser')
         self.assertEqual(standarddir.data(), expected)

 def test_confdir_none(self, mocker):
     """Test --confdir with None given."""
     # patch makedirs to a noop so we don't really create a directory
     mocker.patch('qutebrowser.utils.standarddir.os.makedirs')
     args = types.SimpleNamespace(confdir=None, cachedir=None, datadir=None,
                                  basedir=None)
     standarddir.init(args)
     assert standarddir.config().split(os.sep)[-1] == 'qute_test'

 def test_basedir_relative(self, tmpdir):
     """Test --basedir with a relative path."""
     basedir = (tmpdir / 'basedir')
     basedir.ensure(dir=True)
     with tmpdir.as_cwd():
         args = types.SimpleNamespace(basedir='basedir')
         standarddir.init(args)
         assert standarddir.config() == str(basedir / 'config')

 def test_runtimedir(self, tmpdir, monkeypatch):
     """Test runtime dir (which has no args)."""
     monkeypatch.setattr(
         'qutebrowser.utils.standarddir.QStandardPaths.writableLocation',
         lambda _typ: str(tmpdir))
     args = types.SimpleNamespace(confdir=None, cachedir=None, datadir=None)
     standarddir.init(args)
     assert standarddir.runtime() == str(tmpdir)