test/test_xattr.py

   1 #
   2 #
   3
   4 import sys
   5 import unittest
   6 import tempfile
   7 import os
   8 import errno
   9
  10 import xattr
  11 from xattr import NS_USER, XATTR_CREATE, XATTR_REPLACE
  12
  13 if sys.hexversion >= 0x03000000:
  14     PY3K = True
  15 else:
  16     PY3K = False
  17
  18 TEST_DIR = os.environ.get("TESTDIR", ".")
  19
  20
  21 class xattrTest(unittest.TestCase):
  22     USER_NN = "test"
  23     USER_ATTR = NS_USER.decode() + "." + USER_NN
  24     USER_VAL = "abc"
  25     MANYOPS_COUNT = 131072
  26
  27     if PY3K:
  28         USER_NN = USER_NN.encode()
  29         USER_VAL = USER_VAL.encode()
  30         USER_ATTR = USER_ATTR.encode()
  31
  32     def setUp(self):
  33         """set up function"""
  34         self.rmfiles = []
  35         self.rmdirs = []
  36
  37     def tearDown(self):
  38         """tear down function"""
  39         for fname in self.rmfiles:
  40             try:
  41                 os.unlink(fname)
  42             except EnvironmentError:
  43                 continue
  44         for dname in self.rmdirs:
  45             try:
  46                 os.rmdir(dname)
  47             except EnvironmentError:
  48                 continue
  49
  50     def _getfile(self):
  51         """create a temp file"""
  52         fh, fname = tempfile.mkstemp(".test", "xattr-", TEST_DIR)
  53         self.rmfiles.append(fname)
  54         return fh, fname
  55
  56     def _getdir(self):
  57         """create a temp dir"""
  58         dname = tempfile.mkdtemp(".test", "xattr-", TEST_DIR)
  59         self.rmdirs.append(dname)
  60         return dname
  61
  62     def _getsymlink(self, dangling=True):
  63         """create a symlink"""
  64         fh, fname = self._getfile()
  65         os.close(fh)
  66         if dangling:
  67             os.unlink(fname)
  68         sname = fname + ".symlink"
  69         os.symlink(fname, sname)
  70         self.rmfiles.append(sname)
  71         return fname, sname
  72
  73     def _checkDeprecated(self, item, symlink=False):
  74         """check deprecated list, set, get operations against an item"""
  75         self.assertEqual(xattr.listxattr(item, symlink), [])
  76         self.assertRaises(EnvironmentError, xattr.setxattr, item,
  77                           self.USER_ATTR, self.USER_VAL,
  78                           XATTR_REPLACE)
  79         try:
  80             xattr.setxattr(item, self.USER_ATTR, self.USER_VAL, 0, symlink)
  81         except IOError:
  82             err = sys.exc_info()[1]
  83             if err.errno == errno.EPERM and symlink:
  84                 # symlinks may fail, in which case we abort the rest
  85                 # of the test for this case
  86                 return
  87             raise
  88         self.assertRaises(EnvironmentError, xattr.setxattr, item,
  89                           self.USER_ATTR, self.USER_VAL, XATTR_CREATE)
  90         self.assertEqual(xattr.listxattr(item, symlink), [self.USER_ATTR])
  91         self.assertEqual(xattr.getxattr(item, self.USER_ATTR, symlink),
  92                          self.USER_VAL)
  93         self.assertEqual(xattr.get_all(item, nofollow=symlink),
  94                          [(self.USER_ATTR, self.USER_VAL)])
  95         xattr.removexattr(item, self.USER_ATTR)
  96         self.assertEqual(xattr.listxattr(item, symlink), [])
  97         self.assertEqual(xattr.get_all(item, nofollow=symlink), [])
  98         self.assertRaises(EnvironmentError, xattr.removexattr,
  99                           item, self.USER_ATTR)
 100
 101     def _checkListSetGet(self, item, symlink=False, use_ns=False):
 102         """check list, set, get operations against an item"""
 103         self.assertEqual(xattr.list(item, symlink), [])
 104         self.assertRaises(EnvironmentError, xattr.set, item,
 105                           self.USER_ATTR, self.USER_VAL, flags=XATTR_REPLACE)
 106         self.assertRaises(EnvironmentError, xattr.set, item,
 107                           self.USER_NN, self.USER_VAL, flags=XATTR_REPLACE,
 108                           namespace=NS_USER)
 109         try:
 110             if use_ns:
 111                 xattr.set(item, self.USER_NN, self.USER_VAL,
 112                           namespace=NS_USER,
 113                           nofollow=symlink)
 114             else:
 115                 xattr.set(item, self.USER_ATTR, self.USER_VAL,
 116                           nofollow=symlink)
 117         except IOError:
 118             err = sys.exc_info()[1]
 119             if err.errno == errno.EPERM and symlink:
 120                 # symlinks may fail, in which case we abort the rest
 121                 # of the test for this case
 122                 return
 123             raise
 124         self.assertRaises(EnvironmentError, xattr.set, item,
 125                           self.USER_ATTR, self.USER_VAL, flags=XATTR_CREATE)
 126         self.assertRaises(EnvironmentError, xattr.set, item,
 127                           self.USER_NN, self.USER_VAL,
 128                           flags=XATTR_CREATE, namespace=NS_USER)
 129         self.assertEqual(xattr.list(item, nofollow=symlink), [self.USER_ATTR])
 130         self.assertEqual(xattr.list(item, namespace=NS_USER, nofollow=symlink),
 131                          [self.USER_NN])
 132         self.assertEqual(xattr.get(item, self.USER_ATTR, nofollow=symlink),
 133                          self.USER_VAL)
 134         self.assertEqual(xattr.get(item, self.USER_NN, nofollow=symlink,
 135                                    namespace=NS_USER), self.USER_VAL)
 136         self.assertEqual(xattr.get_all(item, nofollow=symlink),
 137                          [(self.USER_ATTR, self.USER_VAL)])
 138         self.assertEqual(xattr.get_all(item, nofollow=symlink,
 139                                        namespace=NS_USER),
 140                          [(self.USER_NN, self.USER_VAL)])
 141         if use_ns:
 142             xattr.remove(item, self.USER_NN, namespace=NS_USER)
 143         else:
 144             xattr.remove(item, self.USER_ATTR)
 145         self.assertEqual(xattr.list(item, symlink), [])
 146         self.assertEqual(xattr.get_all(item, nofollow=symlink), [])
 147         self.assertRaises(EnvironmentError, xattr.remove,
 148                           item, self.USER_ATTR, nofollow=symlink)
 149         self.assertRaises(EnvironmentError, xattr.remove, item,
 150                           self.USER_NN, namespace=NS_USER, nofollow=symlink)
 151
 152     def testNoXattrDeprecated(self):
 153         """test no attributes (deprecated functions)"""
 154         fh, fname = self._getfile()
 155         self.assertEqual(xattr.listxattr(fname), [])
 156         self.assertEqual(xattr.get_all(fname), [])
 157         dname = self._getdir()
 158         self.assertEqual(xattr.listxattr(dname), [])
 159         self.assertEqual(xattr.get_all(dname), [])
 160         _, sname = self._getsymlink()
 161         self.assertEqual(xattr.listxattr(sname, True), [])
 162         self.assertEqual(xattr.get_all(sname, nofollow=True), [])
 163
 164     def testNoXattr(self):
 165         """test no attributes"""
 166         fh, fname = self._getfile()
 167         self.assertEqual(xattr.list(fname), [])
 168         self.assertEqual(xattr.list(fname, namespace=NS_USER), [])
 169         self.assertEqual(xattr.get_all(fname), [])
 170         self.assertEqual(xattr.get_all(fname, namespace=NS_USER), [])
 171         dname = self._getdir()
 172         self.assertEqual(xattr.list(dname), [])
 173         self.assertEqual(xattr.list(dname, namespace=NS_USER), [])
 174         self.assertEqual(xattr.get_all(dname), [])
 175         self.assertEqual(xattr.get_all(dname, namespace=NS_USER), [])
 176         _, sname = self._getsymlink()
 177         self.assertEqual(xattr.list(sname, nofollow=True), [])
 178         self.assertEqual(xattr.list(sname, nofollow=True,
 179                                         namespace=NS_USER), [])
 180         self.assertEqual(xattr.get_all(sname, nofollow=True), [])
 181         self.assertEqual(xattr.get_all(sname, nofollow=True,
 182                                            namespace=NS_USER), [])
 183
 184     def testFileByNameDeprecated(self):
 185         """test set and retrieve one attribute by file name (deprecated)"""
 186         fh, fname = self._getfile()
 187         self._checkDeprecated(fname)
 188         os.close(fh)
 189
 190     def testFileByName(self):
 191         """test set and retrieve one attribute by file name"""
 192         fh, fname = self._getfile()
 193         self._checkListSetGet(fname)
 194         self._checkListSetGet(fname, use_ns=True)
 195         os.close(fh)
 196
 197     def testFileByDescriptorDeprecated(self):
 198         """test file descriptor operations (deprecated functions)"""
 199         fh, fname = self._getfile()
 200         self._checkDeprecated(fh)
 201         os.close(fh)
 202
 203     def testFileByDescriptor(self):
 204         """test file descriptor operations"""
 205         fh, fname = self._getfile()
 206         self._checkListSetGet(fh)
 207         self._checkListSetGet(fh, use_ns=True)
 208         os.close(fh)
 209
 210     def testFileByObjectDeprecated(self):
 211         """test file descriptor operations (deprecated functions)"""
 212         fh, fname = self._getfile()
 213         fo = os.fdopen(fh)
 214         self._checkDeprecated(fo)
 215         fo.close()
 216
 217     def testFileByObject(self):
 218         """test file descriptor operations"""
 219         fh, fname = self._getfile()
 220         fo = os.fdopen(fh)
 221         self._checkListSetGet(fo)
 222         self._checkListSetGet(fo, use_ns=True)
 223         fo.close()
 224
 225     def testMixedAccessDeprecated(self):
 226         """test mixed access to file (deprecated functions)"""
 227         fh, fname = self._getfile()
 228         fo = os.fdopen(fh)
 229         self.assertEqual(xattr.listxattr(fname), [])
 230         xattr.setxattr(fname, self.USER_ATTR, self.USER_VAL)
 231         self.assertEqual(xattr.listxattr(fh), [self.USER_ATTR])
 232         self.assertEqual(xattr.getxattr(fo, self.USER_ATTR), self.USER_VAL)
 233         self.assertEqual(xattr.get_all(fo), [(self.USER_ATTR, self.USER_VAL)])
 234         self.assertEqual(xattr.get_all(fname),
 235                          [(self.USER_ATTR, self.USER_VAL)])
 236         fo.close()
 237
 238     def testMixedAccess(self):
 239         """test mixed access to file"""
 240         fh, fname = self._getfile()
 241         fo = os.fdopen(fh)
 242         self.assertEqual(xattr.list(fname), [])
 243         xattr.set(fname, self.USER_ATTR, self.USER_VAL)
 244         self.assertEqual(xattr.list(fh), [self.USER_ATTR])
 245         self.assertEqual(xattr.list(fh, namespace=NS_USER), [self.USER_NN])
 246         self.assertEqual(xattr.get(fo, self.USER_ATTR), self.USER_VAL)
 247         self.assertEqual(xattr.get(fo, self.USER_NN, namespace=NS_USER),
 248                          self.USER_VAL)
 249         self.assertEqual(xattr.get_all(fo), [(self.USER_ATTR, self.USER_VAL)])
 250         self.assertEqual(xattr.get_all(fo, namespace=NS_USER),
 251                          [(self.USER_NN, self.USER_VAL)])
 252         self.assertEqual(xattr.get_all(fname),
 253                          [(self.USER_ATTR, self.USER_VAL)])
 254         self.assertEqual(xattr.get_all(fname, namespace=NS_USER),
 255                          [(self.USER_NN, self.USER_VAL)])
 256         fo.close()
 257
 258     def testDirOpsDeprecated(self):
 259         """test attribute setting on directories (deprecated functions)"""
 260         dname = self._getdir()
 261         self._checkDeprecated(dname)
 262
 263     def testDirOps(self):
 264         """test attribute setting on directories"""
 265         dname = self._getdir()
 266         self._checkListSetGet(dname)
 267         self._checkListSetGet(dname, use_ns=True)
 268
 269     def testSymlinkOpsDeprecated(self):
 270         """test symlink operations (deprecated functions)"""
 271         _, sname = self._getsymlink()
 272         self.assertRaises(EnvironmentError, xattr.listxattr, sname)
 273         self._checkDeprecated(sname, symlink=True)
 274         target, sname = self._getsymlink(dangling=False)
 275         xattr.setxattr(target, self.USER_ATTR, self.USER_VAL)
 276         self.assertEqual(xattr.listxattr(target), [self.USER_ATTR])
 277         self.assertEqual(xattr.listxattr(sname, True), [])
 278         self.assertRaises(EnvironmentError, xattr.removexattr, sname,
 279                           self.USER_ATTR, True)
 280         xattr.removexattr(sname, self.USER_ATTR, False)
 281
 282     def testSymlinkOps(self):
 283         """test symlink operations"""
 284         _, sname = self._getsymlink()
 285         self.assertRaises(EnvironmentError, xattr.list, sname)
 286         self._checkListSetGet(sname, symlink=True)
 287         self._checkListSetGet(sname, symlink=True, use_ns=True)
 288         target, sname = self._getsymlink(dangling=False)
 289         xattr.set(target, self.USER_ATTR, self.USER_VAL)
 290         self.assertEqual(xattr.list(target), [self.USER_ATTR])
 291         self.assertEqual(xattr.list(sname, nofollow=True), [])
 292         self.assertRaises(EnvironmentError, xattr.remove, sname,
 293                           self.USER_ATTR, nofollow=True)
 294         xattr.remove(sname, self.USER_ATTR, nofollow=False)
 295
 296     def testBinaryPayloadDeprecated(self):
 297         """test binary values (deprecated functions)"""
 298         fh, fname = self._getfile()
 299         os.close(fh)
 300         BINVAL = "abc" + '\0' + "def"
 301         if PY3K:
 302             BINVAL = BINVAL.encode()
 303         xattr.setxattr(fname, self.USER_ATTR, BINVAL)
 304         self.assertEqual(xattr.listxattr(fname), [self.USER_ATTR])
 305         self.assertEqual(xattr.getxattr(fname, self.USER_ATTR), BINVAL)
 306         self.assertEqual(xattr.get_all(fname), [(self.USER_ATTR, BINVAL)])
 307         xattr.removexattr(fname, self.USER_ATTR)
 308
 309     def testBinaryPayload(self):
 310         """test binary values"""
 311         fh, fname = self._getfile()
 312         os.close(fh)
 313         BINVAL = "abc" + '\0' + "def"
 314         if PY3K:
 315             BINVAL = BINVAL.encode()
 316         xattr.set(fname, self.USER_ATTR, BINVAL)
 317         self.assertEqual(xattr.list(fname), [self.USER_ATTR])
 318         self.assertEqual(xattr.list(fname, namespace=NS_USER), [self.USER_NN])
 319         self.assertEqual(xattr.get(fname, self.USER_ATTR), BINVAL)
 320         self.assertEqual(xattr.get(fname, self.USER_NN,
 321                                    namespace=NS_USER), BINVAL)
 322         self.assertEqual(xattr.get_all(fname), [(self.USER_ATTR, BINVAL)])
 323         self.assertEqual(xattr.get_all(fname, namespace=NS_USER),
 324                          [(self.USER_NN, BINVAL)])
 325         xattr.remove(fname, self.USER_ATTR)
 326
 327     def testManyOpsDeprecated(self):
 328         """test many ops (deprecated functions)"""
 329         fh, fname = self._getfile()
 330         xattr.setxattr(fh, self.USER_ATTR, self.USER_VAL)
 331         VL = [self.USER_ATTR]
 332         for i in range(self.MANYOPS_COUNT):
 333             self.assertEqual(xattr.listxattr(fh), VL)
 334         for i in range(self.MANYOPS_COUNT):
 335             self.assertEqual(xattr.getxattr(fh, self.USER_ATTR), self.USER_VAL)
 336         for i in range(self.MANYOPS_COUNT):
 337             self.assertEqual(xattr.get_all(fh),
 338                              [(self.USER_ATTR, self.USER_VAL)])
 339
 340     def testManyOps(self):
 341         """test many ops"""
 342         fh, fname = self._getfile()
 343         xattr.set(fh, self.USER_ATTR, self.USER_VAL)
 344         VL = [self.USER_ATTR]
 345         VN = [self.USER_NN]
 346         for i in range(self.MANYOPS_COUNT):
 347             self.assertEqual(xattr.list(fh), VL)
 348             self.assertEqual(xattr.list(fh, namespace=NS_USER), VN)
 349         for i in range(self.MANYOPS_COUNT):
 350             self.assertEqual(xattr.get(fh, self.USER_ATTR), self.USER_VAL)
 351             self.assertEqual(xattr.get(fh, self.USER_NN, namespace=NS_USER),
 352                              self.USER_VAL)
 353         for i in range(self.MANYOPS_COUNT):
 354             self.assertEqual(xattr.get_all(fh),
 355                              [(self.USER_ATTR, self.USER_VAL)])
 356             self.assertEqual(xattr.get_all(fh, namespace=NS_USER),
 357                              [(self.USER_NN, self.USER_VAL)])
 358
 359 if __name__ == "__main__":
 360     unittest.main()