tests/test_acls.py

   1 #
   2 #
   3
   4 """Unittests for the posix1e module"""
   5
   6 #  Copyright (C) 2002-2009, 2012, 2014, 2015 Iustin Pop <iustin@k1024.org>
   7 #
   8 #  This library is free software; you can redistribute it and/or
   9 #  modify it under the terms of the GNU Lesser General Public
  10 #  License as published by the Free Software Foundation; either
  11 #  version 2.1 of the License, or (at your option) any later version.
  12 #
  13 #  This library is distributed in the hope that it will be useful,
  14 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 #  Lesser General Public License for more details.
  17 #
  18 #  You should have received a copy of the GNU Lesser General Public
  19 #  License along with this library; if not, write to the Free Software
  20 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21 #  02110-1301  USA
  22
  23
  24 import unittest
  25 import os
  26 import tempfile
  27 import sys
  28 import platform
  29 import re
  30 import errno
  31 import operator
  32 import pytest
  33 import contextlib
  34
  35 import posix1e
  36 from posix1e import *
  37
  38 try:
  39   import __pypy__
  40 except ImportError:
  41   __pypy__ = None
  42
  43 TEST_DIR = os.environ.get("TEST_DIR", ".")
  44
  45 BASIC_ACL_TEXT = "u::rw,g::r,o::-"
  46
  47 # This is to workaround python 2/3 differences at syntactic level
  48 # (which can't be worked around via if's)
  49 M0500 = 320 # octal 0500
  50 M0644 = 420 # octal 0644
  51 M0755 = 493 # octal 755
  52
  53 # Permset permission information
  54 PERMSETS = {
  55   posix1e.ACL_READ: ("read", posix1e.Permset.read),
  56   posix1e.ACL_WRITE: ("write", posix1e.Permset.write),
  57   posix1e.ACL_EXECUTE: ("execute", posix1e.Permset.execute),
  58   }
  59
  60
  61 # Check if running under Python 3
  62 IS_PY_3K = sys.hexversion >= 0x03000000
  63
  64 # Fixtures and helpers
  65
  66 def ignore_ioerror(errnum, fn, *args, **kwargs):
  67     """Call a function while ignoring some IOErrors.
  68
  69     This is needed as some OSes (e.g. FreeBSD) return failure (EINVAL)
  70     when doing certain operations on an invalid ACL.
  71
  72     """
  73     try:
  74         fn(*args, **kwargs)
  75     except IOError:
  76         err = sys.exc_info()[1]
  77         if err.errno == errnum:
  78             return
  79         raise
  80
  81 def encode(s):
  82     """Encode a string if needed (under Python 3)"""
  83     if IS_PY_3K:
  84         return s.encode()
  85     else:
  86         return s
  87
  88 @pytest.fixture
  89 def testdir():
  90     """per-test temp dir based in TEST_DIR"""
  91     with tempfile.TemporaryDirectory(dir=TEST_DIR) as dname:
  92         yield dname
  93
  94 def get_file(path):
  95     fh, fname = tempfile.mkstemp(".test", "xattr-", path)
  96     return fh, fname
  97
  98 @contextlib.contextmanager
  99 def get_file_name(path):
 100     fh, fname = get_file(path)
 101     os.close(fh)
 102     yield fname
 103
 104 @contextlib.contextmanager
 105 def get_file_fd(path):
 106     fd = get_file(path)[0]
 107     yield fd
 108     os.close(fd)
 109
 110 @contextlib.contextmanager
 111 def get_file_object(path):
 112     fd = get_file(path)[0]
 113     with os.fdopen(fd) as f:
 114         yield f
 115
 116 @contextlib.contextmanager
 117 def get_dir(path):
 118     yield tempfile.mkdtemp(".test", "xattr-", path)
 119
 120 def get_symlink(path, dangling=True):
 121     """create a symlink"""
 122     fh, fname = get_file(path)
 123     os.close(fh)
 124     if dangling:
 125         os.unlink(fname)
 126     sname = fname + ".symlink"
 127     os.symlink(fname, sname)
 128     return fname, sname
 129
 130 @contextlib.contextmanager
 131 def get_valid_symlink(path):
 132     yield get_symlink(path, dangling=False)[1]
 133
 134 @contextlib.contextmanager
 135 def get_dangling_symlink(path):
 136     yield get_symlink(path, dangling=True)[1]
 137
 138 @contextlib.contextmanager
 139 def get_file_and_symlink(path):
 140     yield get_symlink(path, dangling=False)
 141
 142 @contextlib.contextmanager
 143 def get_file_and_fobject(path):
 144     fh, fname = get_file(path)
 145     with os.fdopen(fh) as fo:
 146         yield fname, fo
 147
 148 # Wrappers that build upon existing values
 149
 150 def as_wrapper(call, fn, closer=None):
 151     @contextlib.contextmanager
 152     def f(path):
 153         with call(path) as r:
 154             val = fn(r)
 155             yield val
 156             if closer is not None:
 157                 closer(val)
 158     return f
 159
 160 def as_bytes(call):
 161     return as_wrapper(call, lambda r: r.encode())
 162
 163 def as_fspath(call):
 164     return as_wrapper(call, pathlib.PurePath)
 165
 166 def as_iostream(call):
 167     opener = lambda f: io.open(f, "r")
 168     closer = lambda r: r.close()
 169     return as_wrapper(call, opener, closer)
 170
 171 NOT_BEFORE_36 = pytest.mark.xfail(condition="sys.version_info < (3,6)",
 172                                   strict=True)
 173 NOT_PYPY = pytest.mark.xfail(condition="platform.python_implementation() == 'PyPy'",
 174                                   strict=False)
 175
 176 class aclTest:
 177     """Support functions ACLs"""
 178
 179     def setUp(self):
 180         """set up function"""
 181         self.rmfiles = []
 182         self.rmdirs = []
 183
 184     def tearDown(self):
 185         """tear down function"""
 186         for fname in self.rmfiles:
 187             os.unlink(fname)
 188         for dname in self.rmdirs:
 189             os.rmdir(dname)
 190
 191     def _getfile(self):
 192         """create a temp file"""
 193         fh, fname = tempfile.mkstemp(".test", "xattr-", TEST_DIR)
 194         self.rmfiles.append(fname)
 195         return fh, fname
 196
 197     def _getdir(self):
 198         """create a temp dir"""
 199         dname = tempfile.mkdtemp(".test", "xattr-", TEST_DIR)
 200         self.rmdirs.append(dname)
 201         return dname
 202
 203     def _getsymlink(self):
 204         """create a symlink"""
 205         fh, fname = self._getfile()
 206         os.close(fh)
 207         os.unlink(fname)
 208         os.symlink(fname + ".non-existent", fname)
 209         return fname
 210
 211
 212 class TestLoad:
 213     """Load/create tests"""
 214     def test_from_file(self, testdir):
 215         """Test loading ACLs from a file"""
 216         _, fname = get_file(testdir)
 217         acl1 = posix1e.ACL(file=fname)
 218         assert acl1.valid()
 219
 220     def test_from_dir(self, testdir):
 221         """Test loading ACLs from a directory"""
 222         with get_dir(testdir) as dname:
 223           acl1 = posix1e.ACL(file=dname)
 224           acl2 = posix1e.ACL(filedef=dname)
 225           assert acl1.valid()
 226         # default ACLs might or might not be valid; missing ones are
 227         # not valid, so we don't test acl2 for validity
 228
 229     def test_from_fd(self, testdir):
 230         """Test loading ACLs from a file descriptor"""
 231         fd, _ = get_file(testdir)
 232         acl1 = posix1e.ACL(fd=fd)
 233         assert acl1.valid()
 234
 235     def test_from_empty_invalid(self):
 236         """Test creating an empty ACL"""
 237         acl1 = posix1e.ACL()
 238         assert not acl1.valid()
 239
 240     def test_from_text(self):
 241         """Test creating an ACL from text"""
 242         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 243         assert acl1.valid()
 244
 245     def test_from_acl(self):
 246         """Test creating an ACL from an existing ACL"""
 247         acl1 = posix1e.ACL()
 248         acl2 = posix1e.ACL(acl=acl1)
 249         assert acl1 == acl2
 250
 251     def test_invalid_creation_params(self, testdir):
 252         """Test that creating an ACL from multiple objects fails"""
 253         fd, _ = get_file(testdir)
 254         with pytest.raises(ValueError):
 255           posix1e.ACL(text=BASIC_ACL_TEXT, fd=fd)
 256
 257     def test_invalid_value_creation(self):
 258         """Test that creating an ACL from wrong specification fails"""
 259         with pytest.raises(EnvironmentError):
 260           posix1e.ACL(text="foobar")
 261         with pytest.raises(TypeError):
 262           posix1e.ACL(foo="bar")
 263
 264     def test_double_init(self):
 265         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 266         assert acl1.valid()
 267         acl1.__init__(text=BASIC_ACL_TEXT)
 268         assert acl1.valid()
 269
 270 class AclExtensions(aclTest, unittest.TestCase):
 271     """ACL extensions checks"""
 272
 273     @unittest.skipUnless(HAS_ACL_FROM_MODE, "Missing HAS_ACL_FROM_MODE")
 274     def testFromMode(self):
 275         """Test loading ACLs from an octal mode"""
 276         acl1 = posix1e.ACL(mode=M0644)
 277         self.assertTrue(acl1.valid(),
 278                         "ACL created via octal mode shoule be valid")
 279
 280     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 281     def testAclCheck(self):
 282         """Test the acl_check method"""
 283         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 284         self.assertFalse(acl1.check(), "ACL is not valid")
 285         acl2 = posix1e.ACL()
 286         self.assertTrue(acl2.check(), "Empty ACL should not be valid")
 287
 288     @unittest.skipUnless(HAS_EXTENDED_CHECK, "Extended ACL check not supported")
 289     def testExtended(self):
 290         """Test the acl_extended function"""
 291         fd, fname = self._getfile()
 292         basic_acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 293         basic_acl.applyto(fd)
 294         for item in fd, fname:
 295             self.assertFalse(has_extended(item),
 296                              "A simple ACL should not be reported as extended")
 297         enhanced_acl = posix1e.ACL(text="u::rw,g::-,o::-,u:root:rw,mask::r")
 298         self.assertTrue(enhanced_acl.valid(),
 299                         "Failure to build an extended ACL")
 300         enhanced_acl.applyto(fd)
 301         for item in fd, fname:
 302             self.assertTrue(has_extended(item),
 303                             "An extended ACL should be reported as such")
 304
 305     @unittest.skipUnless(HAS_EXTENDED_CHECK, "Extended ACL check not supported")
 306     def testExtendedArgHandling(self):
 307       self.assertRaises(TypeError, has_extended)
 308       self.assertRaises(TypeError, has_extended, object())
 309
 310     @unittest.skipUnless(HAS_EQUIV_MODE, "equiv_mode not supported")
 311     def testEquivMode(self):
 312         """Test the equiv_mode function"""
 313         if HAS_ACL_FROM_MODE:
 314             for mode in M0644, M0755:
 315                 acl = posix1e.ACL(mode=mode)
 316                 self.assertEqual(acl.equiv_mode(), mode)
 317         acl = posix1e.ACL(text="u::rw,g::r,o::r")
 318         self.assertEqual(acl.equiv_mode(), M0644)
 319         acl = posix1e.ACL(text="u::rx,g::-,o::-")
 320         self.assertEqual(acl.equiv_mode(), M0500)
 321
 322     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 323     def testToAnyText(self):
 324         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 325         self.assertIn(encode("u::"),
 326                           acl.to_any_text(options=posix1e.TEXT_ABBREVIATE))
 327         self.assertIn(encode("user::"), acl.to_any_text())
 328
 329     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 330     def testToAnyTextWrongArgs(self):
 331         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 332         self.assertRaises(TypeError, acl.to_any_text, foo="bar")
 333
 334
 335     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 336     def testRichCompare(self):
 337         acl1 = posix1e.ACL(text="u::rw,g::r,o::r")
 338         acl2 = posix1e.ACL(acl=acl1)
 339         acl3 = posix1e.ACL(text="u::rw,g::rw,o::r")
 340         self.assertEqual(acl1, acl2)
 341         self.assertNotEqual(acl1, acl3)
 342         self.assertRaises(TypeError, operator.lt, acl1, acl2)
 343         self.assertRaises(TypeError, operator.ge, acl1, acl3)
 344         self.assertTrue(acl1 != True)
 345         self.assertFalse(acl1 == 1)
 346         self.assertRaises(TypeError, operator.gt, acl1, True)
 347
 348     @unittest.skipUnless(hasattr(posix1e.ACL, "__cmp__"), "__cmp__ is missing")
 349     @unittest.skipUnless(__pypy__ is None, "Disabled under pypy")
 350     def testCmp(self):
 351         acl1 = posix1e.ACL()
 352         self.assertRaises(TypeError, acl1.__cmp__, acl1)
 353
 354     def testApplyToWithWrongObject(self):
 355         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 356         self.assertTrue(acl1.valid())
 357         self.assertRaises(TypeError, acl1.applyto, object())
 358         self.assertRaises(TypeError, acl1.applyto, object(), object())
 359
 360     @unittest.skipUnless(HAS_ACL_ENTRY, "ACL entries not supported")
 361     def testAclIterator(self):
 362         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 363         #self.assertEqual(len(acl), 3)
 364         for entry in acl:
 365             self.assertIs(entry.parent, acl)
 366
 367
 368 class WriteTests(aclTest, unittest.TestCase):
 369     """Write tests"""
 370
 371     def testDeleteDefault(self):
 372         """Test removing the default ACL"""
 373         dname = self._getdir()
 374         posix1e.delete_default(dname)
 375
 376     @unittest.skipUnless(__pypy__ is None, "Disabled under pypy")
 377     def testDeleteDefaultWrongArg(self):
 378         self.assertRaises(TypeError, posix1e.delete_default, object())
 379
 380     def testReapply(self):
 381         """Test re-applying an ACL"""
 382         fd, fname = self._getfile()
 383         acl1 = posix1e.ACL(fd=fd)
 384         acl1.applyto(fd)
 385         acl1.applyto(fname)
 386         dname = self._getdir()
 387         acl2 = posix1e.ACL(file=fname)
 388         acl2.applyto(dname)
 389
 390
 391 @unittest.skipUnless(HAS_ACL_ENTRY, "ACL entries not supported")
 392 class ModificationTests(aclTest, unittest.TestCase):
 393     """ACL modification tests"""
 394
 395     def checkRef(self, obj):
 396         """Checks if a given obj has a 'sane' refcount"""
 397         if platform.python_implementation() == "PyPy":
 398             return
 399         ref_cnt = sys.getrefcount(obj)
 400         # FIXME: hardcoded value for the max ref count... but I've
 401         # seen it overflow on bad reference counting, so it's better
 402         # to be safe
 403         if ref_cnt < 2 or ref_cnt > 1024:
 404             self.fail("Wrong reference count, expected 2-1024 and got %d" %
 405                       ref_cnt)
 406
 407     def testStr(self):
 408         """Test str() of an ACL."""
 409         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 410         str_acl = str(acl)
 411         self.checkRef(str_acl)
 412
 413     def testAppend(self):
 414         """Test append a new Entry to the ACL"""
 415         acl = posix1e.ACL()
 416         e = acl.append()
 417         e.tag_type = posix1e.ACL_OTHER
 418         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 419         str_format = str(e)
 420         self.checkRef(str_format)
 421         e2 = acl.append(e)
 422         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 423         self.assertFalse(acl.valid())
 424
 425     def testWrongAppend(self):
 426         """Test append a new Entry to the ACL based on wrong object type"""
 427         acl = posix1e.ACL()
 428         self.assertRaises(TypeError, acl.append, object())
 429
 430     def testEntryCreation(self):
 431         acl = posix1e.ACL()
 432         e = posix1e.Entry(acl)
 433         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 434         str_format = str(e)
 435         self.checkRef(str_format)
 436
 437     def testEntryFailedCreation(self):
 438         # Checks for partial initialisation and deletion on error
 439         # path.
 440         self.assertRaises(TypeError, posix1e.Entry, object())
 441
 442     def testDelete(self):
 443         """Test delete Entry from the ACL"""
 444         acl = posix1e.ACL()
 445         e = acl.append()
 446         e.tag_type = posix1e.ACL_OTHER
 447         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 448         acl.delete_entry(e)
 449         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 450
 451     def testDoubleDelete(self):
 452         """Test delete Entry from the ACL"""
 453         # This is not entirely valid/correct, since the entry object
 454         # itself is invalid after the first deletion, so we're
 455         # actually testing deleting an invalid object, not a
 456         # non-existing entry...
 457         acl = posix1e.ACL()
 458         e = acl.append()
 459         e.tag_type = posix1e.ACL_OTHER
 460         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 461         acl.delete_entry(e)
 462         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 463         self.assertRaises(EnvironmentError, acl.delete_entry, e)
 464
 465     # This currently fails as this deletion seems to be accepted :/
 466     @unittest.skip("Entry deletion is unreliable")
 467     def testDeleteInvalidEntry(self):
 468         """Test delete foreign Entry from the ACL"""
 469         acl1 = posix1e.ACL()
 470         acl2 = posix1e.ACL()
 471         e = acl1.append()
 472         e.tag_type = posix1e.ACL_OTHER
 473         ignore_ioerror(errno.EINVAL, acl1.calc_mask)
 474         self.assertRaises(EnvironmentError, acl2.delete_entry, e)
 475
 476     def testDeleteInvalidObject(self):
 477         """Test delete a non-Entry from the ACL"""
 478         acl = posix1e.ACL()
 479         self.assertRaises(TypeError, acl.delete_entry, object())
 480
 481     def testDoubleEntries(self):
 482         """Test double entries"""
 483         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 484         self.assertTrue(acl.valid(), "ACL is not valid")
 485         for tag_type in (posix1e.ACL_USER_OBJ, posix1e.ACL_GROUP_OBJ,
 486                          posix1e.ACL_OTHER):
 487             e = acl.append()
 488             e.tag_type = tag_type
 489             e.permset.clear()
 490             self.assertFalse(acl.valid(),
 491                 "ACL containing duplicate entries"
 492                 " should not be valid")
 493             acl.delete_entry(e)
 494
 495     def testMultipleGoodEntries(self):
 496         """Test multiple valid entries"""
 497         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 498         self.assertTrue(acl.valid(), "ACL is not valid")
 499         for tag_type in (posix1e.ACL_USER,
 500                          posix1e.ACL_GROUP):
 501             for obj_id in range(5):
 502                 e = acl.append()
 503                 e.tag_type = tag_type
 504                 e.qualifier = obj_id
 505                 e.permset.clear()
 506                 acl.calc_mask()
 507                 self.assertTrue(acl.valid(),
 508                     "ACL should be able to hold multiple"
 509                     " user/group entries")
 510
 511     def testMultipleBadEntries(self):
 512         """Test multiple invalid entries"""
 513         for tag_type in (posix1e.ACL_USER,
 514                          posix1e.ACL_GROUP):
 515             acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 516             self.assertTrue(acl.valid(), "ACL built from standard description"
 517                                          " should be valid")
 518             e1 = acl.append()
 519             e1.tag_type = tag_type
 520             e1.qualifier = 0
 521             e1.permset.clear()
 522             acl.calc_mask()
 523             self.assertTrue(acl.valid(), "ACL should be able to add a"
 524                 " user/group entry")
 525             e2 = acl.append()
 526             e2.tag_type = tag_type
 527             e2.qualifier = 0
 528             e2.permset.clear()
 529             ignore_ioerror(errno.EINVAL, acl.calc_mask)
 530             self.assertFalse(acl.valid(), "ACL should not validate when"
 531                 " containing two duplicate entries")
 532             acl.delete_entry(e1)
 533             # FreeBSD trips over itself here and can't delete the
 534             # entry, even though it still exists.
 535             ignore_ioerror(errno.EINVAL, acl.delete_entry, e2)
 536
 537     def testCopy(self):
 538         acl = ACL()
 539         e1 = acl.append()
 540         e1.tag_type = ACL_USER
 541         p1 = e1.permset
 542         p1.clear()
 543         p1.read = True
 544         p1.write = True
 545         e2 = acl.append()
 546         e2.tag_type = ACL_GROUP
 547         p2 = e2.permset
 548         p2.clear()
 549         p2.read = True
 550         self.assertFalse(p2.write)
 551         e2.copy(e1)
 552         self.assertTrue(p2.write)
 553         self.assertEqual(e1.tag_type, e2.tag_type)
 554
 555     def testCopyWrongArg(self):
 556         acl = ACL()
 557         e = acl.append()
 558         self.assertRaises(TypeError, e.copy, object())
 559
 560     def testSetPermset(self):
 561         acl = ACL()
 562         e1 = acl.append()
 563         e1.tag_type = ACL_USER
 564         p1 = e1.permset
 565         p1.clear()
 566         p1.read = True
 567         p1.write = True
 568         e2 = acl.append()
 569         e2.tag_type = ACL_GROUP
 570         p2 = e2.permset
 571         p2.clear()
 572         p2.read = True
 573         self.assertFalse(p2.write)
 574         e2.permset = p1
 575         self.assertTrue(e2.permset.write)
 576         self.assertEqual(e2.tag_type, ACL_GROUP)
 577
 578     def testSetPermsetWrongArg(self):
 579         acl = ACL()
 580         e = acl.append()
 581         def setter(v):
 582             e.permset = v
 583         self.assertRaises(TypeError, setter, object())
 584
 585     def testPermsetCreation(self):
 586         acl = ACL()
 587         e = acl.append()
 588         p1 = e.permset
 589         p2 = Permset(e)
 590         #self.assertEqual(p1, p2)
 591
 592     def testPermsetCreationWrongArg(self):
 593         self.assertRaises(TypeError, Permset, object())
 594
 595     def testPermset(self):
 596         """Test permissions"""
 597         acl = posix1e.ACL()
 598         e = acl.append()
 599         ps = e.permset
 600         ps.clear()
 601         str_ps = str(ps)
 602         self.checkRef(str_ps)
 603         for perm in PERMSETS:
 604             str_ps = str(ps)
 605             txt = PERMSETS[perm][0]
 606             self.checkRef(str_ps)
 607             self.assertFalse(ps.test(perm), "Empty permission set should not"
 608                 " have permission '%s'" % txt)
 609             ps.add(perm)
 610             self.assertTrue(ps.test(perm), "Permission '%s' should exist"
 611                 " after addition" % txt)
 612             str_ps = str(ps)
 613             self.checkRef(str_ps)
 614             ps.delete(perm)
 615             self.assertFalse(ps.test(perm), "Permission '%s' should not exist"
 616                 " after deletion" % txt)
 617
 618     def testPermsetViaAccessors(self):
 619         """Test permissions"""
 620         acl = posix1e.ACL()
 621         e = acl.append()
 622         ps = e.permset
 623         ps.clear()
 624         str_ps = str(ps)
 625         self.checkRef(str_ps)
 626         def getter(perm):
 627             return PERMSETS[perm][1].__get__(ps)
 628         def setter(parm, value):
 629             return PERMSETS[perm][1].__set__(ps, value)
 630         for perm in PERMSETS:
 631             str_ps = str(ps)
 632             self.checkRef(str_ps)
 633             txt = PERMSETS[perm][0]
 634             self.assertFalse(getter(perm), "Empty permission set should not"
 635                 " have permission '%s'" % txt)
 636             setter(perm, True)
 637             self.assertTrue(ps.test(perm), "Permission '%s' should exist"
 638                 " after addition" % txt)
 639             self.assertTrue(getter(perm), "Permission '%s' should exist"
 640                 " after addition" % txt)
 641             str_ps = str(ps)
 642             self.checkRef(str_ps)
 643             setter(perm, False)
 644             self.assertFalse(ps.test(perm), "Permission '%s' should not exist"
 645                 " after deletion" % txt)
 646             self.assertFalse(getter(perm), "Permission '%s' should not exist"
 647                 " after deletion" % txt)
 648
 649     def testPermsetInvalidType(self):
 650         acl = posix1e.ACL()
 651         e = acl.append()
 652         ps = e.permset
 653         ps.clear()
 654         def setter():
 655             ps.write = object()
 656         self.assertRaises(TypeError, ps.add, "foobar")
 657         self.assertRaises(TypeError, ps.delete, "foobar")
 658         self.assertRaises(TypeError, ps.test, "foobar")
 659         self.assertRaises(ValueError, setter)
 660
 661     @unittest.skipUnless(IS_PY_3K, "Only supported under Python 3")
 662     def testQualifierValues(self):
 663         """Tests qualifier correct store/retrieval"""
 664         acl = posix1e.ACL()
 665         e = acl.append()
 666         # work around deprecation warnings
 667         if hasattr(self, 'assertRegex'):
 668             fn = self.assertRegex
 669         else:
 670             fn = self.assertRegexpMatches
 671         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP]:
 672             qualifier = 1
 673             e.tag_type = tag
 674             while True:
 675                 if tag == posix1e.ACL_USER:
 676                     regex = re.compile("user with uid %d" % qualifier)
 677                 else:
 678                     regex = re.compile("group with gid %d" % qualifier)
 679                 try:
 680                     e.qualifier = qualifier
 681                 except OverflowError:
 682                     # reached overflow condition, break
 683                     break
 684                 self.assertEqual(e.qualifier, qualifier)
 685                 fn(str(e), regex)
 686                 qualifier *= 2
 687
 688     @unittest.skipUnless(IS_PY_3K, "Only supported under Python 3")
 689     def testQualifierOverflow(self):
 690         """Tests qualifier overflow handling"""
 691         acl = posix1e.ACL()
 692         e = acl.append()
 693         qualifier = sys.maxsize * 2
 694         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP]:
 695             e.tag_type = tag
 696             with self.assertRaises(OverflowError):
 697                 e.qualifier = qualifier
 698
 699     @unittest.skipUnless(IS_PY_3K, "Only supported under Python 3")
 700     def testNegativeQualifier(self):
 701         """Tests negative qualifier handling"""
 702         # Note: this presumes that uid_t/gid_t in C are unsigned...
 703         acl = posix1e.ACL()
 704         e = acl.append()
 705         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP]:
 706             e.tag_type = tag
 707             for qualifier in [-10, -5, -1]:
 708                 with self.assertRaises(OverflowError):
 709                     e.qualifier = qualifier
 710
 711     def testInvalidQualifier(self):
 712         """Tests invalid qualifier handling"""
 713         acl = posix1e.ACL()
 714         e = acl.append()
 715         def set_qual(x):
 716             e.qualifier = x
 717         def del_qual():
 718             del e.qualifier
 719         self.assertRaises(TypeError, set_qual, object())
 720         self.assertRaises((TypeError, AttributeError), del_qual)
 721
 722     def testQualifierOnWrongTag(self):
 723         """Tests qualifier setting on wrong tag"""
 724         acl = posix1e.ACL()
 725         e = acl.append()
 726         e.tag_type = posix1e.ACL_OTHER
 727         def set_qual(x):
 728             e.qualifier = x
 729         def get_qual():
 730             return e.qualifier
 731         self.assertRaises(TypeError, set_qual, 1)
 732         self.assertRaises(TypeError, get_qual)
 733
 734
 735     def testTagTypes(self):
 736         """Tests tag type correct set/get"""
 737         acl = posix1e.ACL()
 738         e = acl.append()
 739         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP, posix1e.ACL_USER_OBJ,
 740                     posix1e.ACL_GROUP_OBJ, posix1e.ACL_MASK,
 741                     posix1e.ACL_OTHER]:
 742             e.tag_type = tag
 743             self.assertEqual(e.tag_type, tag)
 744             # check we can show all tag types without breaking
 745             self.assertTrue(str(e))
 746
 747     def testInvalidTags(self):
 748         """Tests tag type incorrect set/get"""
 749         acl = posix1e.ACL()
 750         e = acl.append()
 751         def set_tag(x):
 752           e.tag_type = x
 753         self.assertRaises(TypeError, set_tag, object())
 754         def delete_tag():
 755           del e.tag_type
 756         # For some reason, PyPy raises AttributeError. Strange...
 757         self.assertRaises((TypeError, AttributeError), delete_tag)
 758
 759         e.tag_type = posix1e.ACL_USER_OBJ
 760         tag = max([posix1e.ACL_USER, posix1e.ACL_GROUP, posix1e.ACL_USER_OBJ,
 761                    posix1e.ACL_GROUP_OBJ, posix1e.ACL_MASK,
 762                    posix1e.ACL_OTHER]) + 1
 763         self.assertRaises(EnvironmentError, set_tag, tag)
 764         # Check tag is still valid.
 765         self.assertEqual(e.tag_type, posix1e.ACL_USER_OBJ)
 766
 767 if __name__ == "__main__":
 768     unittest.main()