Remove use of deprecated fail* test functions
[pyxattr.git] / 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
237     def testMixedAccess(self):
238         """test mixed access to file"""
239         fh, fname = self._getfile()
240         fo = os.fdopen(fh)
241         self.assertEqual(xattr.list(fname), [])
242         xattr.set(fname, self.USER_ATTR, self.USER_VAL)
243         self.assertEqual(xattr.list(fh), [self.USER_ATTR])
244         self.assertEqual(xattr.list(fh, namespace=NS_USER), [self.USER_NN])
245         self.assertEqual(xattr.get(fo, self.USER_ATTR), self.USER_VAL)
246         self.assertEqual(xattr.get(fo, self.USER_NN, namespace=NS_USER),
247                          self.USER_VAL)
248         self.assertEqual(xattr.get_all(fo), [(self.USER_ATTR, self.USER_VAL)])
249         self.assertEqual(xattr.get_all(fo, namespace=NS_USER),
250                          [(self.USER_NN, self.USER_VAL)])
251         self.assertEqual(xattr.get_all(fname),
252                          [(self.USER_ATTR, self.USER_VAL)])
253         self.assertEqual(xattr.get_all(fname, namespace=NS_USER),
254                          [(self.USER_NN, self.USER_VAL)])
255
256     def testDirOpsDeprecated(self):
257         """test attribute setting on directories (deprecated functions)"""
258         dname = self._getdir()
259         self._checkDeprecated(dname)
260
261     def testDirOps(self):
262         """test attribute setting on directories"""
263         dname = self._getdir()
264         self._checkListSetGet(dname)
265         self._checkListSetGet(dname, use_ns=True)
266
267     def testSymlinkOpsDeprecated(self):
268         """test symlink operations (deprecated functions)"""
269         _, sname = self._getsymlink()
270         self.assertRaises(EnvironmentError, xattr.listxattr, sname)
271         self._checkDeprecated(sname, symlink=True)
272         target, sname = self._getsymlink(dangling=False)
273         xattr.setxattr(target, self.USER_ATTR, self.USER_VAL)
274         self.assertEqual(xattr.listxattr(target), [self.USER_ATTR])
275         self.assertEqual(xattr.listxattr(sname, True), [])
276         self.assertRaises(EnvironmentError, xattr.removexattr, sname,
277                           self.USER_ATTR, True)
278         xattr.removexattr(sname, self.USER_ATTR, False)
279
280     def testSymlinkOps(self):
281         """test symlink operations"""
282         _, sname = self._getsymlink()
283         self.assertRaises(EnvironmentError, xattr.list, sname)
284         self._checkListSetGet(sname, symlink=True)
285         self._checkListSetGet(sname, symlink=True, use_ns=True)
286         target, sname = self._getsymlink(dangling=False)
287         xattr.set(target, self.USER_ATTR, self.USER_VAL)
288         self.assertEqual(xattr.list(target), [self.USER_ATTR])
289         self.assertEqual(xattr.list(sname, nofollow=True), [])
290         self.assertRaises(EnvironmentError, xattr.remove, sname,
291                           self.USER_ATTR, nofollow=True)
292         xattr.remove(sname, self.USER_ATTR, nofollow=False)
293
294     def testBinaryPayloadDeprecated(self):
295         """test binary values (deprecated functions)"""
296         fh, fname = self._getfile()
297         os.close(fh)
298         BINVAL = "abc" + '\0' + "def"
299         if PY3K:
300             BINVAL = BINVAL.encode()
301         xattr.setxattr(fname, self.USER_ATTR, BINVAL)
302         self.assertEqual(xattr.listxattr(fname), [self.USER_ATTR])
303         self.assertEqual(xattr.getxattr(fname, self.USER_ATTR), BINVAL)
304         self.assertEqual(xattr.get_all(fname), [(self.USER_ATTR, BINVAL)])
305         xattr.removexattr(fname, self.USER_ATTR)
306
307     def testBinaryPayload(self):
308         """test binary values"""
309         fh, fname = self._getfile()
310         os.close(fh)
311         BINVAL = "abc" + '\0' + "def"
312         if PY3K:
313             BINVAL = BINVAL.encode()
314         xattr.set(fname, self.USER_ATTR, BINVAL)
315         self.assertEqual(xattr.list(fname), [self.USER_ATTR])
316         self.assertEqual(xattr.list(fname, namespace=NS_USER), [self.USER_NN])
317         self.assertEqual(xattr.get(fname, self.USER_ATTR), BINVAL)
318         self.assertEqual(xattr.get(fname, self.USER_NN,
319                                    namespace=NS_USER), BINVAL)
320         self.assertEqual(xattr.get_all(fname), [(self.USER_ATTR, BINVAL)])
321         self.assertEqual(xattr.get_all(fname, namespace=NS_USER),
322                          [(self.USER_NN, BINVAL)])
323         xattr.remove(fname, self.USER_ATTR)
324
325     def testManyOpsDeprecated(self):
326         """test many ops (deprecated functions)"""
327         fh, fname = self._getfile()
328         xattr.setxattr(fh, self.USER_ATTR, self.USER_VAL)
329         VL = [self.USER_ATTR]
330         for i in range(self.MANYOPS_COUNT):
331             self.assertEqual(xattr.listxattr(fh), VL)
332         for i in range(self.MANYOPS_COUNT):
333             self.assertEqual(xattr.getxattr(fh, self.USER_ATTR), self.USER_VAL)
334         for i in range(self.MANYOPS_COUNT):
335             self.assertEqual(xattr.get_all(fh),
336                              [(self.USER_ATTR, self.USER_VAL)])
337
338     def testManyOps(self):
339         """test many ops"""
340         fh, fname = self._getfile()
341         xattr.set(fh, self.USER_ATTR, self.USER_VAL)
342         VL = [self.USER_ATTR]
343         VN = [self.USER_NN]
344         for i in range(self.MANYOPS_COUNT):
345             self.assertEqual(xattr.list(fh), VL)
346             self.assertEqual(xattr.list(fh, namespace=NS_USER), VN)
347         for i in range(self.MANYOPS_COUNT):
348             self.assertEqual(xattr.get(fh, self.USER_ATTR), self.USER_VAL)
349             self.assertEqual(xattr.get(fh, self.USER_NN, namespace=NS_USER),
350                              self.USER_VAL)
351         for i in range(self.MANYOPS_COUNT):
352             self.assertEqual(xattr.get_all(fh),
353                              [(self.USER_ATTR, self.USER_VAL)])
354             self.assertEqual(xattr.get_all(fh, namespace=NS_USER),
355                              [(self.USER_NN, self.USER_VAL)])
356
357 if __name__ == "__main__":
358     unittest.main()