← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_win32utils.py

  • Committer: Patch Queue Manager
  • Date: 2016-01-31 13:36:59 UTC
  • mfrom: (6613.1.5 1538480-match-hostname)
  • Revision ID: pqm@pqm.ubuntu.com-20160131133659-ouy92ee2wlv9xz8m
(vila) Use ssl.match_hostname instead of our own. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_win32utils.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tests for win32utils."""
18
18
 
19
19
import os
20
 
import sys
21
20
 
22
21
from bzrlib import (
23
22
    osutils,
 
23
    symbol_versioning,
24
24
    tests,
25
25
    win32utils,
26
26
    )
27
27
from bzrlib.tests import (
28
 
    Feature,
29
28
    TestCase,
30
29
    TestCaseInTempDir,
31
30
    TestSkipped,
32
 
    UnicodeFilenameFeature,
33
31
    )
34
32
from bzrlib.tests.features import backslashdir_feature
35
33
from bzrlib.win32utils import glob_expand, get_app_path
36
 
 
37
 
 
38
 
class _RequiredModuleFeature(Feature):
39
 
 
40
 
    def __init__(self, mod_name):
41
 
        self.mod_name = mod_name
42
 
        super(_RequiredModuleFeature, self).__init__()
43
 
 
44
 
    def _probe(self):
45
 
        try:
46
 
            __import__(self.mod_name)
47
 
            return True
48
 
        except ImportError:
49
 
            return False
50
 
 
51
 
    def feature_name(self):
52
 
        return self.mod_name
53
 
 
54
 
Win32RegistryFeature = _RequiredModuleFeature('_winreg')
55
 
CtypesFeature = _RequiredModuleFeature('ctypes')
56
 
Win32comShellFeature = _RequiredModuleFeature('win32com.shell')
57
 
Win32ApiFeature = _RequiredModuleFeature('win32api') 
 
34
from bzrlib.tests import (
 
35
    features,
 
36
    )
 
37
 
 
38
 
 
39
Win32RegistryFeature = features.ModuleAvailableFeature('_winreg')
 
40
CtypesFeature = features.ModuleAvailableFeature('ctypes')
 
41
Win32comShellFeature = features.ModuleAvailableFeature('win32com.shell')
 
42
Win32ApiFeature = features.ModuleAvailableFeature('win32api') 
58
43
 
59
44
 
60
45
# Tests
79
64
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
80
65
 
81
66
    def build_unicode_tree(self):
82
 
        self.requireFeature(UnicodeFilenameFeature)
 
67
        self.requireFeature(features.UnicodeFilenameFeature)
83
68
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
84
69
                         u'\u1235/\u1235'])
85
70
 
120
105
            ])
121
106
 
122
107
    def test_case_insensitive_globbing(self):
123
 
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
 
108
        if os.path.normcase("AbC") == "AbC":
 
109
            self.skip("Test requires case insensitive globbing function")
124
110
        self.build_ascii_tree()
125
111
        self._run_testset([
126
112
            [[u'A'], [u'A']],
202
188
        self.assertEquals('not-existing', p)
203
189
 
204
190
 
 
191
class TestLocations(TestCase):
 
192
    """Tests for windows specific path and name retrieving functions"""
 
193
 
 
194
    def test__ensure_unicode_deprecated(self):
 
195
        s = "text"
 
196
        u1 = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
 
197
            win32utils._ensure_unicode, s)
 
198
        self.assertEqual(s, u1)
 
199
        self.assertIsInstance(u1, unicode)
 
200
        u2 = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
 
201
            win32utils._ensure_unicode, u1)
 
202
        self.assertIs(u1, u2)
 
203
    
 
204
    def test_appdata_unicode_deprecated(self):
 
205
        self.overrideEnv("APPDATA", "fakepath")
 
206
        s = win32utils.get_appdata_location()
 
207
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
 
208
            win32utils.get_appdata_location_unicode)
 
209
        self.assertEqual(s, u)
 
210
        self.assertIsInstance(s, unicode)
 
211
 
 
212
    def test_home_unicode_deprecated(self):
 
213
        s = win32utils.get_home_location()
 
214
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
 
215
            win32utils.get_home_location_unicode)
 
216
        self.assertEqual(s, u)
 
217
        self.assertIsInstance(s, unicode)
 
218
 
 
219
    def test_user_unicode_deprecated(self):
 
220
        self.overrideEnv("USERNAME", "alien")
 
221
        s = win32utils.get_user_name()
 
222
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
 
223
            win32utils.get_user_name_unicode)
 
224
        self.assertEqual(s, u)
 
225
        self.assertIsInstance(s, unicode)
 
226
 
 
227
    def test_host_unicode_deprecated(self):
 
228
        self.overrideEnv("COMPUTERNAME", "alienbox")
 
229
        s = win32utils.get_host_name()
 
230
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
 
231
            win32utils.get_host_name_unicode)
 
232
        self.assertEqual(s, u)
 
233
        self.assertIsInstance(s, unicode)
 
234
 
 
235
 
205
236
class TestLocationsCtypes(TestCase):
206
237
 
207
238
    _test_needs_features = [CtypesFeature]
216
247
    def test_appdata_not_using_environment(self):
217
248
        # Test that we aren't falling back to the environment
218
249
        first = win32utils.get_appdata_location()
219
 
        self._captureVar("APPDATA", None)
 
250
        self.overrideEnv("APPDATA", None)
220
251
        self.assertPathsEqual(first, win32utils.get_appdata_location())
221
252
 
222
253
    def test_appdata_matches_environment(self):
233
264
    def test_local_appdata_not_using_environment(self):
234
265
        # Test that we aren't falling back to the environment
235
266
        first = win32utils.get_local_appdata_location()
236
 
        self._captureVar("LOCALAPPDATA", None)
 
267
        self.overrideEnv("LOCALAPPDATA", None)
237
268
        self.assertPathsEqual(first, win32utils.get_local_appdata_location())
238
269
 
239
270
    def test_local_appdata_matches_environment(self):
263
294
 
264
295
    def test_unicode_dir(self):
265
296
        # we should handle unicode paths without errors
266
 
        self.requireFeature(UnicodeFilenameFeature)
 
297
        self.requireFeature(features.UnicodeFilenameFeature)
267
298
        os.mkdir(u'\u1234')
268
299
        win32utils.set_file_attr_hidden(u'\u1234')
269
300
 
270
301
    def test_dot_bzr_in_unicode_dir(self):
271
302
        # we should not raise traceback if we try to set hidden attribute
272
303
        # on .bzr directory below unicode path
273
 
        self.requireFeature(UnicodeFilenameFeature)
 
304
        self.requireFeature(features.UnicodeFilenameFeature)
274
305
        os.makedirs(u'\u1234\\.bzr')
275
306
        path = osutils.abspath(u'\u1234\\.bzr')
276
307
        win32utils.set_file_attr_hidden(path)
326
357
            single_quotes_allowed=True)
327
358
 
328
359
    def test_case_insensitive_globs(self):
329
 
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
 
360
        if os.path.normcase("AbC") == "AbC":
 
361
            self.skip("Test requires case insensitive globbing function")
330
362
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
331
363
        self.assertCommandLine([u'A/b.c'], 'A/B*')
332
364
 
342
374
        self.assertCommandLine([u"rm", u"x*"], "-m pdb rm x*", ["rm", u"x*"])
343
375
        self.assertCommandLine([u"add", u"d/f1", u"d/f2"], "-m pdb add d/*",
344
376
            ["add", u"d/*"])
 
377
 
 
378
 
 
379
class TestGetEnvironUnicode(tests.TestCase):
 
380
    """Tests for accessing the environment via the windows wide api"""
 
381
 
 
382
    _test_needs_features = [CtypesFeature, features.win32_feature]
 
383
 
 
384
    def setUp(self):
 
385
        super(TestGetEnvironUnicode, self).setUp()
 
386
        self.overrideEnv("TEST", "1")
 
387
 
 
388
    def test_get(self):
 
389
        """In the normal case behaves the same as os.environ access"""
 
390
        self.assertEqual("1", win32utils.get_environ_unicode("TEST"))
 
391
 
 
392
    def test_unset(self):
 
393
        """A variable not present in the environment gives None by default"""
 
394
        del os.environ["TEST"]
 
395
        self.assertIs(None, win32utils.get_environ_unicode("TEST"))
 
396
 
 
397
    def test_unset_default(self):
 
398
        """A variable not present in the environment gives passed default"""
 
399
        del os.environ["TEST"]
 
400
        self.assertIs("a", win32utils.get_environ_unicode("TEST", "a"))
 
401
 
 
402
    def test_unicode(self):
 
403
        """A non-ascii variable is returned as unicode"""
 
404
        unicode_val = u"\xa7" # non-ascii character present in many encodings
 
405
        try:
 
406
            bytes_val = unicode_val.encode(osutils.get_user_encoding())
 
407
        except UnicodeEncodeError:
 
408
            self.skip("Couldn't encode non-ascii string to place in environ")
 
409
        os.environ["TEST"] = bytes_val
 
410
        self.assertEqual(unicode_val, win32utils.get_environ_unicode("TEST"))
 
411
 
 
412
    def test_long(self):
 
413
        """A variable bigger than heuristic buffer size is still accessible"""
 
414
        big_val = "x" * (2<<10)
 
415
        os.environ["TEST"] = big_val
 
416
        self.assertEqual(big_val, win32utils.get_environ_unicode("TEST"))
 
417
 
 
418
    def test_unexpected_error(self):
 
419
        """An error from the underlying platform function is propogated"""
 
420
        ERROR_INVALID_PARAMETER = 87
 
421
        SetLastError = win32utils.ctypes.windll.kernel32.SetLastError
 
422
        def failer(*args, **kwargs):
 
423
            SetLastError(ERROR_INVALID_PARAMETER)
 
424
            return 0
 
425
        self.overrideAttr(win32utils.get_environ_unicode, "_c_function",
 
426
            failer)
 
427
        e = self.assertRaises(WindowsError,
 
428
            win32utils.get_environ_unicode, "TEST")
 
429
        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)