Merge lp:~yolanda.robla/ubuntu/saucy/open-iscsi/dep-8-tests into lp:ubuntu/saucy/open-iscsi

Proposed by Yolanda Robla on 2013-05-13
Status: Merged
Merged at revision: 43
Proposed branch: lp:~yolanda.robla/ubuntu/saucy/open-iscsi/dep-8-tests
Merge into: lp:ubuntu/saucy/open-iscsi
Diff against target: 1415 lines (+1371/-0)
7 files modified
debian/changelog (+6/-0)
debian/control (+1/-0)
debian/tests/control (+3/-0)
debian/tests/daemon (+15/-0)
debian/tests/test-open-iscsi.py (+195/-0)
debian/tests/testlib.py (+1144/-0)
debian/tests/testsuite (+7/-0)
To merge this branch: bzr merge lp:~yolanda.robla/ubuntu/saucy/open-iscsi/dep-8-tests
Reviewer Review Type Date Requested Status
Martin Pitt 2013-05-13 Approve on 2013-05-27
Review via email: mp+163494@code.launchpad.net

Description of the change

Added dep-8-tests

To post a comment you must log in.
44. By Yolanda Robla on 2013-05-17

added testsuite

Martin Pitt (pitti) wrote :

Verified on current saucy with "run-adt-test -sS lp:~yolanda.robla/ubuntu/saucy/open-iscsi/dep-8-tests open-iscsi". Thanks!

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'debian/changelog'
2--- debian/changelog 2012-10-17 12:37:43 +0000
3+++ debian/changelog 2013-05-17 10:06:26 +0000
4@@ -1,3 +1,9 @@
5+open-iscsi (2.0.873-3ubuntu6) saucy; urgency=low
6+
7+ * d/tests: added dep-8-tests
8+
9+ -- Yolanda <yolanda.robla@canonical.com> Mon, 13 May 2013 10:37:31 +0200
10+
11 open-iscsi (2.0.873-3ubuntu5) quantal-proposed; urgency=low
12
13 * Ensure all udev events have been processed before trying to configure
14
15=== modified file 'debian/control'
16--- debian/control 2012-07-10 13:53:52 +0000
17+++ debian/control 2013-05-17 10:06:26 +0000
18@@ -9,6 +9,7 @@
19 Vcs-Git: git://git.debian.org/git/pkg-iscsi/open-iscsi.git
20 Vcs-Browser: http://git.debian.org/?p=pkg-iscsi/open-iscsi.git
21 Homepage: http://www.open-iscsi.org/
22+XS-Testsuite: autopkgtest
23
24 Package: open-iscsi
25 Architecture: any
26
27=== added directory 'debian/tests'
28=== added file 'debian/tests/control'
29--- debian/tests/control 1970-01-01 00:00:00 +0000
30+++ debian/tests/control 2013-05-17 10:06:26 +0000
31@@ -0,0 +1,3 @@
32+Tests: daemon testsuite
33+Depends: open-iscsi
34+Restrictions: needs-root
35
36=== added file 'debian/tests/daemon'
37--- debian/tests/daemon 1970-01-01 00:00:00 +0000
38+++ debian/tests/daemon 2013-05-17 10:06:26 +0000
39@@ -0,0 +1,15 @@
40+#!/bin/bash
41+#--------------------------
42+# Testing open-iscsi daemon
43+#--------------------------
44+set -e
45+
46+/etc/init.d/open-iscsi start > /dev/null 2>&1
47+
48+if pidof -x iscsid > /dev/null; then
49+ echo "OK"
50+ exit 0
51+else
52+ echo "ERROR: OPEN-ISCSI IS NOT RUNNING"
53+ exit 1
54+fi
55
56=== added file 'debian/tests/test-open-iscsi.py'
57--- debian/tests/test-open-iscsi.py 1970-01-01 00:00:00 +0000
58+++ debian/tests/test-open-iscsi.py 2013-05-17 10:06:26 +0000
59@@ -0,0 +1,195 @@
60+#!/usr/bin/python
61+#
62+# test-open-iscsi.py quality assurance test script for open-iscsi
63+# Copyright (C) 2011 Canonical Ltd.
64+# Author: Jamie Strandboge <jamie@canonical.com>
65+#
66+# This program is free software: you can redistribute it and/or modify
67+# it under the terms of the GNU General Public License version 3,
68+# as published by the Free Software Foundation.
69+#
70+# This program is distributed in the hope that it will be useful,
71+# but WITHOUT ANY WARRANTY; without even the implied warranty of
72+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
73+# GNU General Public License for more details.
74+#
75+# You should have received a copy of the GNU General Public License
76+# along with this program. If not, see <http://www.gnu.org/licenses/>.
77+#
78+# packages required for test to run:
79+# QRT-Packages: open-iscsi
80+# packages where more than one package can satisfy a runtime requirement:
81+# QRT-Alternates:
82+# files and directories required for the test to run:
83+# QRT-Depends:
84+# privilege required for the test to run (remove line if running as user is okay):
85+# QRT-Privilege: root
86+
87+'''
88+ In general, this test should be run in a virtual machine (VM) or possibly
89+ a chroot and not on a production machine. While efforts are made to make
90+ these tests non-destructive, there is no guarantee this script will not
91+ alter the machine. You have been warned.
92+
93+ How to run in a clean VM:
94+ $ sudo apt-get -y install python-unit <QRT-Packages> && sudo ./test-PKG.py -v'
95+
96+ How to run in a clean schroot named 'lucid':
97+ $ schroot -c lucid -u root -- sh -c 'apt-get -y install python-unit <QRT-Packages> && ./test-PKG.py -v'
98+
99+
100+ NOTES:
101+ - currently only tested on Ubuntu 8.04
102+'''
103+
104+
105+import unittest, subprocess, sys, os
106+import testlib
107+import time
108+
109+# There are setup based on README.multipurpose-vm. Feel free to override.
110+remote_server = ''
111+username = 'ubuntu'
112+password = 'passwd'
113+username_in = 'ubuntu'
114+password_in = 'ubuntupasswd'
115+initiatorname = 'iqn.2009-10.com.example.hardy-multi:iscsi-01'
116+
117+try:
118+ from private.qrt.OpenIscsi import PrivateOpenIscsiTest
119+except ImportError:
120+ class PrivateOpenIscsiTest(object):
121+ '''Empty class'''
122+ print >>sys.stdout, "Skipping private tests"
123+
124+class OpenIscsiTest(testlib.TestlibCase, PrivateOpenIscsiTest):
125+ '''Test my thing.'''
126+
127+ def setUp(self):
128+ '''Set up prior to each test_* function'''
129+ self.pidfile = "/var/run/iscsid.pid"
130+ self.exe = "/sbin/iscsid"
131+ self.daemon = testlib.TestDaemon("/etc/init.d/open-iscsi")
132+ self.initiatorname_iscsi = '/etc/iscsi/initiatorname.iscsi'
133+ self.iscsid_conf = '/etc/iscsi/iscsid.conf'
134+
135+ def tearDown(self):
136+ '''Clean up after each test_* function'''
137+ global remote_server
138+ global initiatorname
139+
140+ # If remote server is setup, convert back to manual, logout, remove
141+ # testlib configs and restart (in that order)
142+ if remote_server != '':
143+ testlib.cmd(['iscsiadm', '-m', 'node', '--targetname', initiatorname, '-p', '%s:3260' % remote_server, '--op=update', '--name', 'node.startup', '--value=manual'])
144+ testlib.cmd(['iscsiadm', '-m', 'node', '--targetname', initiatorname, '-p', '%s:3260' % remote_server, '--op=update', '--name', 'node.conn[0].startup', '--value=manual'])
145+ testlib.cmd(['iscsiadm', '-m', 'node', '--targetname', initiatorname, '-p', '%s:3260' % remote_server, '--logout'])
146+
147+ testlib.config_restore(self.initiatorname_iscsi)
148+ testlib.config_restore(self.iscsid_conf)
149+ self.daemon.restart()
150+
151+ def test_daemon(self):
152+ '''Test iscsid'''
153+ self.assertTrue(self.daemon.stop())
154+ time.sleep(2)
155+ self.assertFalse(testlib.check_pidfile(self.exe, self.pidfile))
156+
157+ self.assertTrue(self.daemon.start())
158+ time.sleep(2)
159+ self.assertTrue(testlib.check_pidfile(os.path.basename(self.exe), self.pidfile))
160+
161+ self.assertTrue(self.daemon.restart())
162+ time.sleep(2)
163+ self.assertTrue(testlib.check_pidfile(os.path.basename(self.exe), self.pidfile))
164+
165+ def test_discovery_with_server(self):
166+ '''Test iscsi_discovery to remote server'''
167+ global remote_server
168+ global username
169+ global password
170+ global username_in
171+ global password_in
172+ global initiatorname
173+
174+ if remote_server == '':
175+ return self._skipped("--remote-server not specified")
176+
177+ contents = '''
178+InitiatorName=%s
179+InitiatorAlias=ubuntu
180+''' % (initiatorname)
181+ testlib.config_replace(self.initiatorname_iscsi, contents, True)
182+
183+ contents = '''
184+node.session.auth.authmethod = CHAP
185+node.session.auth.username = %s
186+node.session.auth.password = %s
187+node.session.auth.username_in = %s
188+node.session.auth.password_in = %s
189+
190+discovery.sendtargets.auth.authmethod = CHAP
191+discovery.sendtargets.auth.username = %s
192+discovery.sendtargets.auth.password = %s
193+discovery.sendtargets.auth.username_in = %s
194+discovery.sendtargets.auth.password_in = %s
195+''' % (username, password, username_in, password_in, username, password, username_in, password_in)
196+ testlib.config_replace(self.iscsid_conf, contents, True)
197+
198+ self.assertTrue(self.daemon.restart())
199+ time.sleep(2)
200+ self.assertTrue(testlib.check_pidfile(os.path.basename(self.exe), self.pidfile))
201+
202+ rc, report = testlib.cmd(["/sbin/iscsi_discovery", remote_server])
203+ expected = 0
204+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
205+ self.assertEquals(expected, rc, result + report)
206+ for i in ['starting discovery to %s' % remote_server,
207+ 'Testing iser-login to target %s portal %s' % (initiatorname, remote_server),
208+ 'starting to test tcp-login to target %s portal %s' % (initiatorname, remote_server),
209+ 'discovered 1 targets at %s, connected to 1' % remote_server]:
210+ result = "Could not find '%s' in report:\n" % i
211+ self.assertTrue(i in report, result + report)
212+
213+if __name__ == '__main__':
214+ import optparse
215+ parser = optparse.OptionParser()
216+ parser.add_option("-v", "--verbose", dest="verbose", help="Verbose", action="store_true")
217+ parser.add_option("-s", "--remote-server", dest="remote_server", help="Specify host with available iSCSI volumes", metavar="HOST")
218+
219+ parser.add_option("-n", "--initiatorname", dest="initiatorname", help="Specify initiatorname for use with --remote-server", metavar="NAME")
220+
221+ parser.add_option("--password", dest="password", help="Specify password for use with --remote-server", metavar="PASS")
222+ parser.add_option("--password-in", dest="password_in", help="Specify password_in for use with --remote-server", metavar="PASS")
223+
224+ parser.add_option("--username", dest="username", help="Specify username for use with --remote-server", metavar="USER")
225+ parser.add_option("--username-in", dest="username_in", help="Specify username_in for use with --remote-server", metavar="USER")
226+
227+ (options, args) = parser.parse_args()
228+
229+ if options.remote_server:
230+ remote_server = options.remote_server
231+
232+ if options.username:
233+ username = options.username
234+ if options.password:
235+ password = options.password
236+ if options.username_in:
237+ username_in = options.username_in
238+ if options.password_in:
239+ password_in = options.password_in
240+ if options.initiatorname:
241+ initiatorname = options.initiatorname
242+ print "Connecting to remote server with:"
243+ print " host = %s " % remote_server
244+ print ' initiatorname = %s' % initiatorname
245+ print ' username = %s' % username
246+ print ' password = %s' % password
247+ print ' username_in = %s' % username_in
248+ print ' password_in = %s' % password_in
249+
250+ suite = unittest.TestSuite()
251+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(OpenIscsiTest))
252+ rc = unittest.TextTestRunner(verbosity=2).run(suite)
253+ if not rc.wasSuccessful():
254+ sys.exit(1)
255
256=== added file 'debian/tests/testlib.py'
257--- debian/tests/testlib.py 1970-01-01 00:00:00 +0000
258+++ debian/tests/testlib.py 2013-05-17 10:06:26 +0000
259@@ -0,0 +1,1144 @@
260+#
261+# testlib.py quality assurance test script
262+# Copyright (C) 2008-2011 Canonical Ltd.
263+#
264+# This library is free software; you can redistribute it and/or
265+# modify it under the terms of the GNU Library General Public
266+# License as published by the Free Software Foundation; either
267+# version 2 of the License.
268+#
269+# This library is distributed in the hope that it will be useful,
270+# but WITHOUT ANY WARRANTY; without even the implied warranty of
271+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
272+# Library General Public License for more details.
273+#
274+# You should have received a copy of the GNU Library General Public
275+# License along with this program. If not, see
276+# <http://www.gnu.org/licenses/>.
277+#
278+
279+'''Common classes and functions for package tests.'''
280+
281+import string, random, crypt, subprocess, pwd, grp, signal, time, unittest, tempfile, shutil, os, os.path, re, glob
282+import sys, socket, gzip
283+from stat import *
284+from encodings import string_escape
285+
286+import warnings
287+warnings.filterwarnings('ignore', message=r'.*apt_pkg\.TagFile.*', category=DeprecationWarning)
288+try:
289+ import apt_pkg
290+ apt_pkg.InitSystem();
291+except:
292+ # On non-Debian system, fall back to simple comparison without debianisms
293+ class apt_pkg(object):
294+ def VersionCompare(one, two):
295+ list_one = one.split('.')
296+ list_two = two.split('.')
297+ while len(list_one)>0 and len(list_two)>0:
298+ if list_one[0] > list_two[0]:
299+ return 1
300+ if list_one[0] < list_two[0]:
301+ return -1
302+ list_one.pop(0)
303+ list_two.pop(0)
304+ return 0
305+
306+bogus_nxdomain = "208.69.32.132"
307+
308+# http://www.chiark.greenend.org.uk/ucgi/~cjwatson/blosxom/2009-07-02-python-sigpipe.html
309+# This is needed so that the subprocesses that produce endless output
310+# actually quit when the reader goes away.
311+import signal
312+def subprocess_setup():
313+ # Python installs a SIGPIPE handler by default. This is usually not what
314+ # non-Python subprocesses expect.
315+ signal.signal(signal.SIGPIPE, signal.SIG_DFL)
316+
317+class TimedOutException(Exception):
318+ def __init__(self, value = "Timed Out"):
319+ self.value = value
320+ def __str__(self):
321+ return repr(self.value)
322+
323+def _restore_backup(path):
324+ pathbackup = path + '.autotest'
325+ if os.path.exists(pathbackup):
326+ shutil.move(pathbackup, path)
327+
328+def _save_backup(path):
329+ pathbackup = path + '.autotest'
330+ if os.path.exists(path) and not os.path.exists(pathbackup):
331+ shutil.copy2(path, pathbackup)
332+ # copy2 does not copy ownership, so do it here.
333+ # Reference: http://docs.python.org/library/shutil.html
334+ a = os.stat(path)
335+ os.chown(pathbackup, a[4], a[5])
336+
337+def config_copydir(path):
338+ if os.path.exists(path) and not os.path.isdir(path):
339+ raise OSError, "'%s' is not a directory" % (path)
340+ _restore_backup(path)
341+
342+ pathbackup = path + '.autotest'
343+ if os.path.exists(path):
344+ shutil.copytree(path, pathbackup, symlinks=True)
345+
346+def config_replace(path,contents,append=False):
347+ '''Replace (or append) to a config file'''
348+ _restore_backup(path)
349+ if os.path.exists(path):
350+ _save_backup(path)
351+ if append:
352+ contents = file(path).read() + contents
353+ open(path, 'w').write(contents)
354+
355+def config_comment(path, field):
356+ _save_backup(path)
357+ contents = ""
358+ for line in file(path):
359+ if re.search("^\s*%s\s*=" % (field), line):
360+ line = "#" + line
361+ contents += line
362+
363+ open(path+'.new', 'w').write(contents)
364+ os.rename(path+'.new', path)
365+
366+def config_set(path, field, value, spaces=True):
367+ _save_backup(path)
368+ contents = ""
369+ if spaces==True:
370+ setting = '%s = %s\n' % (field, value)
371+ else:
372+ setting = '%s=%s\n' % (field, value)
373+ found = False
374+ for line in file(path):
375+ if re.search("^\s*%s\s*=" % (field), line):
376+ found = True
377+ line = setting
378+ contents += line
379+ if not found:
380+ contents += setting
381+
382+ open(path+'.new', 'w').write(contents)
383+ os.rename(path+'.new', path)
384+
385+def config_patch(path, patch, depth=1):
386+ '''Patch a config file'''
387+ _restore_backup(path)
388+ _save_backup(path)
389+
390+ handle, name = mkstemp_fill(patch)
391+ rc = subprocess.call(['/usr/bin/patch', '-p%s' %(depth), path], stdin=handle, stdout=subprocess.PIPE)
392+ os.unlink(name)
393+ if rc != 0:
394+ raise Exception("Patch failed")
395+
396+def config_restore(path):
397+ '''Rename a replaced config file back to its initial state'''
398+ _restore_backup(path)
399+
400+def timeout(secs, f, *args):
401+ def handler(signum, frame):
402+ raise TimedOutException()
403+
404+ old = signal.signal(signal.SIGALRM, handler)
405+ result = None
406+ signal.alarm(secs)
407+ try:
408+ result = f(*args)
409+ finally:
410+ signal.alarm(0)
411+ signal.signal(signal.SIGALRM, old)
412+
413+ return result
414+
415+def require_nonroot():
416+ if os.geteuid() == 0:
417+ print >>sys.stderr, "This series of tests should be run as a regular user with sudo access, not as root."
418+ sys.exit(1)
419+
420+def require_root():
421+ if os.geteuid() != 0:
422+ print >>sys.stderr, "This series of tests should be run with root privileges (e.g. via sudo)."
423+ sys.exit(1)
424+
425+def require_sudo():
426+ if os.geteuid() != 0 or os.environ.get('SUDO_USER', None) == None:
427+ print >>sys.stderr, "This series of tests must be run under sudo."
428+ sys.exit(1)
429+ if os.environ['SUDO_USER'] == 'root':
430+ print >>sys.stderr, 'Please run this test using sudo from a regular user. (You ran sudo from root.)'
431+ sys.exit(1)
432+
433+def random_string(length,lower=False):
434+ '''Return a random string, consisting of ASCII letters, with given
435+ length.'''
436+
437+ s = ''
438+ selection = string.letters
439+ if lower:
440+ selection = string.lowercase
441+ maxind = len(selection)-1
442+ for l in range(length):
443+ s += selection[random.randint(0, maxind)]
444+ return s
445+
446+def mkstemp_fill(contents,suffix='',prefix='testlib-',dir=None):
447+ '''As tempfile.mkstemp does, return a (file, name) pair, but with
448+ prefilled contents.'''
449+
450+ handle, name = tempfile.mkstemp(suffix=suffix,prefix=prefix,dir=dir)
451+ os.close(handle)
452+ handle = file(name,"w+")
453+ handle.write(contents)
454+ handle.flush()
455+ handle.seek(0)
456+
457+ return handle, name
458+
459+def create_fill(path, contents, mode=0644):
460+ '''Safely create a page'''
461+ # make the temp file in the same dir as the destination file so we
462+ # don't get invalid cross-device link errors when we rename
463+ handle, name = mkstemp_fill(contents, dir=os.path.dirname(path))
464+ handle.close()
465+ os.rename(name, path)
466+ os.chmod(path, mode)
467+
468+def login_exists(login):
469+ '''Checks whether the given login exists on the system.'''
470+
471+ try:
472+ pwd.getpwnam(login)
473+ return True
474+ except KeyError:
475+ return False
476+
477+def group_exists(group):
478+ '''Checks whether the given login exists on the system.'''
479+
480+ try:
481+ grp.getgrnam(group)
482+ return True
483+ except KeyError:
484+ return False
485+
486+def recursive_rm(dirPath, contents_only=False):
487+ '''recursively remove directory'''
488+ names = os.listdir(dirPath)
489+ for name in names:
490+ path = os.path.join(dirPath, name)
491+ if os.path.islink(path) or not os.path.isdir(path):
492+ os.unlink(path)
493+ else:
494+ recursive_rm(path)
495+ if contents_only == False:
496+ os.rmdir(dirPath)
497+
498+def check_pidfile(exe, pidfile):
499+ '''Checks if pid in pidfile is running'''
500+ if not os.path.exists(pidfile):
501+ return False
502+
503+ # get the pid
504+ try:
505+ fd = open(pidfile, 'r')
506+ pid = fd.readline().rstrip('\n')
507+ fd.close()
508+ except:
509+ return False
510+
511+ return check_pid(exe, pid)
512+
513+def check_pid(exe, pid):
514+ '''Checks if pid is running'''
515+ cmdline = "/proc/%s/cmdline" % (str(pid))
516+ if not os.path.exists(cmdline):
517+ return False
518+
519+ # get the command line
520+ try:
521+ fd = open(cmdline, 'r')
522+ tmp = fd.readline().split('\0')
523+ fd.close()
524+ except:
525+ return False
526+
527+ # this allows us to match absolute paths or just the executable name
528+ if re.match('^' + exe + '$', tmp[0]) or \
529+ re.match('.*/' + exe + '$', tmp[0]) or \
530+ re.match('^' + exe + ': ', tmp[0]) or \
531+ re.match('^\(' + exe + '\)', tmp[0]):
532+ return True
533+
534+ return False
535+
536+def check_port(port, proto, ver=4):
537+ '''Check if something is listening on the specified port.
538+ WARNING: for some reason this does not work with a bind mounted /proc
539+ '''
540+ assert (port >= 1)
541+ assert (port <= 65535)
542+ assert (proto.lower() == "tcp" or proto.lower() == "udp")
543+ assert (ver == 4 or ver == 6)
544+
545+ fn = "/proc/net/%s" % (proto)
546+ if ver == 6:
547+ fn += str(ver)
548+
549+ rc, report = cmd(['cat', fn])
550+ assert (rc == 0)
551+
552+ hport = "%0.4x" % port
553+
554+ if re.search(': [0-9a-f]{8}:%s [0-9a-f]' % str(hport).lower(), report.lower()):
555+ return True
556+ return False
557+
558+def get_arch():
559+ '''Get the current architecture'''
560+ rc, report = cmd(['uname', '-m'])
561+ assert (rc == 0)
562+ return report.strip()
563+
564+def get_memory():
565+ '''Gets total ram and swap'''
566+ meminfo = "/proc/meminfo"
567+ memtotal = 0
568+ swaptotal = 0
569+ if not os.path.exists(meminfo):
570+ return (False, False)
571+
572+ try:
573+ fd = open(meminfo, 'r')
574+ for line in fd.readlines():
575+ splitline = line.split()
576+ if splitline[0] == 'MemTotal:':
577+ memtotal = int(splitline[1])
578+ elif splitline[0] == 'SwapTotal:':
579+ swaptotal = int(splitline[1])
580+ fd.close()
581+ except:
582+ return (False, False)
583+
584+ return (memtotal,swaptotal)
585+
586+def is_running_in_vm():
587+ '''Check if running under a VM'''
588+ # add other virtualization environments here
589+ for search in ['QEMU Virtual CPU']:
590+ rc, report = cmd_pipe(['dmesg'], ['grep', search])
591+ if rc == 0:
592+ return True
593+ return False
594+
595+def ubuntu_release():
596+ '''Get the Ubuntu release'''
597+ f = "/etc/lsb-release"
598+ try:
599+ size = os.stat(f)[ST_SIZE]
600+ except:
601+ return "UNKNOWN"
602+
603+ if size > 1024*1024:
604+ raise IOError, 'Could not open "%s" (too big)' % f
605+
606+ try:
607+ fh = open("/etc/lsb-release", 'r')
608+ except:
609+ raise
610+
611+ lines = fh.readlines()
612+ fh.close()
613+
614+ pat = re.compile(r'DISTRIB_CODENAME')
615+ for line in lines:
616+ if pat.search(line):
617+ return line.split('=')[1].rstrip('\n').rstrip('\r')
618+
619+ return "UNKNOWN"
620+
621+def cmd(command, input = None, stderr = subprocess.STDOUT, stdout = subprocess.PIPE, stdin = None, timeout = None):
622+ '''Try to execute given command (array) and return its stdout, or return
623+ a textual error if it failed.'''
624+
625+ try:
626+ sp = subprocess.Popen(command, stdin=stdin, stdout=stdout, stderr=stderr, close_fds=True, preexec_fn=subprocess_setup)
627+ except OSError, e:
628+ return [127, str(e)]
629+
630+ out, outerr = sp.communicate(input)
631+ # Handle redirection of stdout
632+ if out == None:
633+ out = ''
634+ # Handle redirection of stderr
635+ if outerr == None:
636+ outerr = ''
637+ return [sp.returncode,out+outerr]
638+
639+def cmd_pipe(command1, command2, input = None, stderr = subprocess.STDOUT, stdin = None):
640+ '''Try to pipe command1 into command2.'''
641+ try:
642+ sp1 = subprocess.Popen(command1, stdin=stdin, stdout=subprocess.PIPE, stderr=stderr, close_fds=True)
643+ sp2 = subprocess.Popen(command2, stdin=sp1.stdout, stdout=subprocess.PIPE, stderr=stderr, close_fds=True)
644+ except OSError, e:
645+ return [127, str(e)]
646+
647+ out = sp2.communicate(input)[0]
648+ return [sp2.returncode,out]
649+
650+def cwd_has_enough_space(cdir, total_bytes):
651+ '''Determine if the partition of the current working directory has 'bytes'
652+ free.'''
653+ rc, df_output = cmd(['df'])
654+ result = 'Got exit code %d, expected %d\n' % (rc, 0)
655+ if rc != 0:
656+ return False
657+
658+ kb = total_bytes / 1024
659+
660+ mounts = dict()
661+ for line in df_output.splitlines():
662+ if '/' not in line:
663+ continue
664+ tmp = line.split()
665+ mounts[tmp[5]] = int(tmp[3])
666+
667+ cdir = os.getcwd()
668+ while cdir != '/':
669+ if not mounts.has_key(cdir):
670+ cdir = os.path.dirname(cdir)
671+ continue
672+ if kb < mounts[cdir]:
673+ return True
674+ else:
675+ return False
676+
677+ if kb < mounts['/']:
678+ return True
679+
680+ return False
681+
682+def get_md5(filename):
683+ '''Gets the md5sum of the file specified'''
684+
685+ (rc, report) = cmd(["/usr/bin/md5sum", "-b", filename])
686+ expected = 0
687+ assert (expected == rc)
688+
689+ return report.split(' ')[0]
690+
691+def dpkg_compare_installed_version(pkg, check, version):
692+ '''Gets the version for the installed package, and compares it to the
693+ specified version.
694+ '''
695+ (rc, report) = cmd(["/usr/bin/dpkg", "-s", pkg])
696+ assert (rc == 0)
697+ assert ("Status: install ok installed" in report)
698+ installed_version = ""
699+ for line in report.splitlines():
700+ if line.startswith("Version: "):
701+ installed_version = line.split()[1]
702+
703+ assert (installed_version != "")
704+
705+ (rc, report) = cmd(["/usr/bin/dpkg", "--compare-versions", installed_version, check, version])
706+ assert (rc == 0 or rc == 1)
707+ if rc == 0:
708+ return True
709+ return False
710+
711+def prepare_source(source, builder, cached_src, build_src, patch_system):
712+ '''Download and unpack source package, installing necessary build depends,
713+ adjusting the permissions for the 'builder' user, and returning the
714+ directory of the unpacked source. Patch system can be one of:
715+ - cdbs
716+ - dpatch
717+ - quilt
718+ - quiltv3
719+ - None (not the string)
720+
721+ This is normally used like this:
722+
723+ def setUp(self):
724+ ...
725+ self.topdir = os.getcwd()
726+ self.cached_src = os.path.join(os.getcwd(), "source")
727+ self.tmpdir = tempfile.mkdtemp(prefix='testlib', dir='/tmp')
728+ self.builder = testlib.TestUser()
729+ testlib.cmd(['chgrp', self.builder.login, self.tmpdir])
730+ os.chmod(self.tmpdir, 0775)
731+
732+ def tearDown(self):
733+ ...
734+ self.builder = None
735+ self.topdir = os.getcwd()
736+ if os.path.exists(self.tmpdir):
737+ testlib.recursive_rm(self.tmpdir)
738+
739+ def test_suite_build(self):
740+ ...
741+ build_dir = testlib.prepare_source('foo', \
742+ self.builder, \
743+ self.cached_src, \
744+ os.path.join(self.tmpdir, \
745+ os.path.basename(self.cached_src)),
746+ "quilt")
747+ os.chdir(build_dir)
748+
749+ # Example for typical build, adjust as necessary
750+ print ""
751+ print " make clean"
752+ rc, report = testlib.cmd(['sudo', '-u', self.builder.login, 'make', 'clean'])
753+
754+ print " configure"
755+ rc, report = testlib.cmd(['sudo', '-u', self.builder.login, './configure', '--prefix=%s' % self.tmpdir, '--enable-debug'])
756+
757+ print " make (will take a while)"
758+ rc, report = testlib.cmd(['sudo', '-u', self.builder.login, 'make'])
759+
760+ print " make check (will take a while)",
761+ rc, report = testlib.cmd(['sudo', '-u', self.builder.login, 'make', 'check'])
762+ expected = 0
763+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
764+ self.assertEquals(expected, rc, result + report)
765+
766+ def test_suite_cleanup(self):
767+ ...
768+ if os.path.exists(self.cached_src):
769+ testlib.recursive_rm(self.cached_src)
770+
771+ It is up to the caller to clean up cached_src and build_src (as in the
772+ above example, often the build_src is in a tmpdir that is cleaned in
773+ tearDown() and the cached_src is cleaned in a one time clean-up
774+ operation (eg 'test_suite_cleanup()) which must be run after the build
775+ suite test (obviously).
776+ '''
777+
778+ # Make sure we have a clean slate
779+ assert (os.path.exists(os.path.dirname(build_src)))
780+ assert (not os.path.exists(build_src))
781+
782+ cdir = os.getcwd()
783+ if os.path.exists(cached_src):
784+ shutil.copytree(cached_src, build_src)
785+ os.chdir(build_src)
786+ else:
787+ # Only install the build dependencies on the initial setup
788+ rc, report = cmd(['apt-get','-y','--force-yes','build-dep',source])
789+ assert (rc == 0)
790+
791+ os.makedirs(build_src)
792+ os.chdir(build_src)
793+
794+ # These are always needed
795+ pkgs = ['build-essential', 'dpkg-dev', 'fakeroot']
796+ rc, report = cmd(['apt-get','-y','--force-yes','install'] + pkgs)
797+ assert (rc == 0)
798+
799+ rc, report = cmd(['apt-get','source',source])
800+ assert (rc == 0)
801+ shutil.copytree(build_src, cached_src)
802+
803+ unpacked_dir = os.path.join(build_src, glob.glob('%s-*' % source)[0])
804+
805+ # Now apply the patches. Do it here so that we don't mess up our cached
806+ # sources.
807+ os.chdir(unpacked_dir)
808+ assert (patch_system in ['cdbs', 'dpatch', 'quilt', 'quiltv3', None])
809+ if patch_system != None and patch_system != "quiltv3":
810+ if patch_system == "quilt":
811+ os.environ.setdefault('QUILT_PATCHES','debian/patches')
812+ rc, report = cmd(['quilt', 'push', '-a'])
813+ assert (rc == 0)
814+ elif patch_system == "cdbs":
815+ rc, report = cmd(['./debian/rules', 'apply-patches'])
816+ assert (rc == 0)
817+ elif patch_system == "dpatch":
818+ rc, report = cmd(['dpatch', 'apply-all'])
819+ assert (rc == 0)
820+
821+ cmd(['chown', '-R', '%s:%s' % (builder.uid, builder.gid), build_src])
822+ os.chdir(cdir)
823+
824+ return unpacked_dir
825+
826+def _aa_status():
827+ '''Get aa-status output'''
828+ exe = "/usr/sbin/aa-status"
829+ assert (os.path.exists(exe))
830+ if os.geteuid() == 0:
831+ return cmd([exe])
832+ return cmd(['sudo', exe])
833+
834+def is_apparmor_loaded(path):
835+ '''Check if profile is loaded'''
836+ rc, report = _aa_status()
837+ if rc != 0:
838+ return False
839+
840+ for line in report.splitlines():
841+ if line.endswith(path):
842+ return True
843+ return False
844+
845+def is_apparmor_confined(path):
846+ '''Check if application is confined'''
847+ rc, report = _aa_status()
848+ if rc != 0:
849+ return False
850+
851+ for line in report.splitlines():
852+ if re.search('%s \(' % path, line):
853+ return True
854+ return False
855+
856+def check_apparmor(path, first_ubuntu_release, is_running=True):
857+ '''Check if path is loaded and confined for everything higher than the
858+ first Ubuntu release specified.
859+
860+ Usage:
861+ rc, report = testlib.check_apparmor('/usr/sbin/foo', 8.04, is_running=True)
862+ if rc < 0:
863+ return self._skipped(report)
864+
865+ expected = 0
866+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
867+ self.assertEquals(expected, rc, result + report)
868+ '''
869+ global manager
870+ rc = -1
871+
872+ if manager.lsb_release["Release"] < first_ubuntu_release:
873+ return (rc, "Skipped apparmor check")
874+
875+ if not os.path.exists('/sbin/apparmor_parser'):
876+ return (rc, "Skipped (couldn't find apparmor_parser)")
877+
878+ rc = 0
879+ msg = ""
880+ if not is_apparmor_loaded(path):
881+ rc = 1
882+ msg = "Profile not loaded for '%s'" % path
883+
884+ # this check only makes sense it the 'path' is currently executing
885+ if is_running and rc == 0 and not is_apparmor_confined(path):
886+ rc = 1
887+ msg = "'%s' is not running in enforce mode" % path
888+
889+ return (rc, msg)
890+
891+def get_gcc_version(gcc, full=True):
892+ gcc_version = 'none'
893+ if not gcc.startswith('/'):
894+ gcc = '/usr/bin/%s' % (gcc)
895+ if os.path.exists(gcc):
896+ gcc_version = 'unknown'
897+ lines = cmd([gcc,'-v'])[1].strip().splitlines()
898+ version_lines = [x for x in lines if x.startswith('gcc version')]
899+ if len(version_lines) == 1:
900+ gcc_version = " ".join(version_lines[0].split()[2:])
901+ if not full:
902+ return gcc_version.split()[0]
903+ return gcc_version
904+
905+def is_kdeinit_running():
906+ '''Test if kdeinit is running'''
907+ # applications that use kdeinit will spawn it if it isn't running in the
908+ # test. This is a problem because it does not exit. This is a helper to
909+ # check for it.
910+ rc, report = cmd(['ps', 'x'])
911+ if 'kdeinit4 Running' not in report:
912+ print >>sys.stderr, ("kdeinit not running (you may start/stop any KDE application then run this script again)")
913+ return False
914+ return True
915+
916+def get_pkgconfig_flags(libs=[]):
917+ '''Find pkg-config flags for libraries'''
918+ assert (len(libs) > 0)
919+ rc, pkg_config = cmd(['pkg-config', '--cflags', '--libs'] + libs)
920+ expected = 0
921+ if rc != expected:
922+ print >>sys.stderr, 'Got exit code %d, expected %d\n' % (rc, expected)
923+ assert(rc == expected)
924+ return pkg_config.split()
925+
926+class TestDaemon:
927+ '''Helper class to manage daemons consistently'''
928+ def __init__(self, init):
929+ '''Setup daemon attributes'''
930+ self.initscript = init
931+
932+ def start(self):
933+ '''Start daemon'''
934+ rc, report = cmd([self.initscript, 'start'])
935+ expected = 0
936+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
937+ time.sleep(2)
938+ if expected != rc:
939+ return (False, result + report)
940+
941+ if "fail" in report:
942+ return (False, "Found 'fail' in report\n" + report)
943+
944+ return (True, "")
945+
946+ def stop(self):
947+ '''Stop daemon'''
948+ rc, report = cmd([self.initscript, 'stop'])
949+ expected = 0
950+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
951+ if expected != rc:
952+ return (False, result + report)
953+
954+ if "fail" in report:
955+ return (False, "Found 'fail' in report\n" + report)
956+
957+ return (True, "")
958+
959+ def reload(self):
960+ '''Reload daemon'''
961+ rc, report = cmd([self.initscript, 'force-reload'])
962+ expected = 0
963+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
964+ if expected != rc:
965+ return (False, result + report)
966+
967+ if "fail" in report:
968+ return (False, "Found 'fail' in report\n" + report)
969+
970+ return (True, "")
971+
972+ def restart(self):
973+ '''Restart daemon'''
974+ (res, str) = self.stop()
975+ if not res:
976+ return (res, str)
977+
978+ (res, str) = self.start()
979+ if not res:
980+ return (res, str)
981+
982+ return (True, "")
983+
984+ def status(self):
985+ '''Check daemon status'''
986+ rc, report = cmd([self.initscript, 'status'])
987+ expected = 0
988+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
989+ if expected != rc:
990+ return (False, result + report)
991+
992+ if "fail" in report:
993+ return (False, "Found 'fail' in report\n" + report)
994+
995+ return (True, "")
996+
997+class TestlibManager(object):
998+ '''Singleton class used to set up per-test-run information'''
999+ def __init__(self):
1000+ # Set glibc aborts to dump to stderr instead of the tty so test output
1001+ # is more sane.
1002+ os.environ.setdefault('LIBC_FATAL_STDERR_','1')
1003+
1004+ # check verbosity
1005+ self.verbosity = False
1006+ if (len(sys.argv) > 1 and '-v' in sys.argv[1:]):
1007+ self.verbosity = True
1008+
1009+ # Load LSB release file
1010+ self.lsb_release = dict()
1011+ if not os.path.exists('/usr/bin/lsb_release') and not os.path.exists('/bin/lsb_release'):
1012+ raise OSError, "Please install 'lsb-release'"
1013+ for line in subprocess.Popen(['lsb_release','-a'],stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0].splitlines():
1014+ field, value = line.split(':',1)
1015+ value=value.strip()
1016+ field=field.strip()
1017+ # Convert numerics
1018+ try:
1019+ value = float(value)
1020+ except:
1021+ pass
1022+ self.lsb_release.setdefault(field,value)
1023+
1024+ # FIXME: hack OEM releases into known-Ubuntu versions
1025+ if self.lsb_release['Distributor ID'] == "HP MIE (Mobile Internet Experience)":
1026+ if self.lsb_release['Release'] == 1.0:
1027+ self.lsb_release['Distributor ID'] = "Ubuntu"
1028+ self.lsb_release['Release'] = 8.04
1029+ else:
1030+ raise OSError, "Unknown version of HP MIE"
1031+
1032+ # FIXME: hack to assume a most-recent release if we're not
1033+ # running under Ubuntu.
1034+ if self.lsb_release['Distributor ID'] not in ["Ubuntu","Linaro"]:
1035+ self.lsb_release['Release'] = 10000
1036+ # Adjust Linaro release to pretend to be Ubuntu
1037+ if self.lsb_release['Distributor ID'] in ["Linaro"]:
1038+ self.lsb_release['Distributor ID'] = "Ubuntu"
1039+ self.lsb_release['Release'] -= 0.01
1040+
1041+ # Load arch
1042+ if not os.path.exists('/usr/bin/dpkg'):
1043+ machine = cmd(['uname','-m'])[1].strip()
1044+ if machine.endswith('86'):
1045+ self.dpkg_arch = 'i386'
1046+ elif machine.endswith('_64'):
1047+ self.dpkg_arch = 'amd64'
1048+ elif machine.startswith('arm'):
1049+ self.dpkg_arch = 'armel'
1050+ else:
1051+ raise ValueError, "Unknown machine type '%s'" % (machine)
1052+ else:
1053+ self.dpkg_arch = cmd(['dpkg','--print-architecture'])[1].strip()
1054+
1055+ # Find kernel version
1056+ self.kernel_is_ubuntu = False
1057+ self.kernel_version_signature = None
1058+ self.kernel_version = cmd(["uname","-r"])[1].strip()
1059+ versig = '/proc/version_signature'
1060+ if os.path.exists(versig):
1061+ self.kernel_is_ubuntu = True
1062+ self.kernel_version_signature = file(versig).read().strip()
1063+ self.kernel_version_ubuntu = self.kernel_version
1064+ elif os.path.exists('/usr/bin/dpkg'):
1065+ # this can easily be inaccurate but is only an issue for Dapper
1066+ rc, out = cmd(['dpkg','-l','linux-image-%s' % (self.kernel_version)])
1067+ if rc == 0:
1068+ self.kernel_version_signature = out.strip().split('\n').pop().split()[2]
1069+ self.kernel_version_ubuntu = self.kernel_version_signature
1070+ if self.kernel_version_signature == None:
1071+ # Attempt to fall back to something for non-Debian-based
1072+ self.kernel_version_signature = self.kernel_version
1073+ self.kernel_version_ubuntu = self.kernel_version
1074+ # Build ubuntu version without hardware suffix
1075+ try:
1076+ self.kernel_version_ubuntu = "-".join([x for x in self.kernel_version_signature.split(' ')[1].split('-') if re.search('^[0-9]', x)])
1077+ except:
1078+ pass
1079+
1080+ # Find gcc version
1081+ self.gcc_version = get_gcc_version('gcc')
1082+
1083+ # Find libc
1084+ self.path_libc = [x.split()[2] for x in cmd(['ldd','/bin/ls'])[1].splitlines() if x.startswith('\tlibc.so.')][0]
1085+
1086+ # Report self
1087+ if self.verbosity:
1088+ kernel = self.kernel_version_ubuntu
1089+ if kernel != self.kernel_version_signature:
1090+ kernel += " (%s)" % (self.kernel_version_signature)
1091+ print >>sys.stdout, "Running test: '%s' distro: '%s %.2f' kernel: '%s' arch: '%s' uid: %d/%d SUDO_USER: '%s')" % ( \
1092+ sys.argv[0],
1093+ self.lsb_release['Distributor ID'],
1094+ self.lsb_release['Release'],
1095+ kernel,
1096+ self.dpkg_arch,
1097+ os.geteuid(), os.getuid(),
1098+ os.environ.get('SUDO_USER', ''))
1099+ sys.stdout.flush()
1100+
1101+ # Additional heuristics
1102+ #if os.environ.get('SUDO_USER', os.environ.get('USER', '')) in ['mdeslaur']:
1103+ # sys.stdout.write("Replying to Marc Deslauriers in http://launchpad.net/bugs/%d: " % random.randint(600000, 980000))
1104+ # sys.stdout.flush()
1105+ # time.sleep(0.5)
1106+ # sys.stdout.write("destroyed\n")
1107+ # time.sleep(0.5)
1108+
1109+ def hello(self, msg):
1110+ print >>sys.stderr, "Hello from %s" % (msg)
1111+# The central instance
1112+manager = TestlibManager()
1113+
1114+class TestlibCase(unittest.TestCase):
1115+ def __init__(self, *args):
1116+ '''This is called for each TestCase test instance, which isn't much better
1117+ than SetUp.'''
1118+
1119+ unittest.TestCase.__init__(self, *args)
1120+
1121+ # Attach to and duplicate dicts from manager singleton
1122+ self.manager = manager
1123+ #self.manager.hello(repr(self) + repr(*args))
1124+ self.my_verbosity = self.manager.verbosity
1125+ self.lsb_release = self.manager.lsb_release
1126+ self.dpkg_arch = self.manager.dpkg_arch
1127+ self.kernel_version = self.manager.kernel_version
1128+ self.kernel_version_signature = self.manager.kernel_version_signature
1129+ self.kernel_version_ubuntu = self.manager.kernel_version_ubuntu
1130+ self.kernel_is_ubuntu = self.manager.kernel_is_ubuntu
1131+ self.gcc_version = self.manager.gcc_version
1132+ self.path_libc = self.manager.path_libc
1133+
1134+ def version_compare(self, one, two):
1135+ return apt_pkg.VersionCompare(one,two)
1136+
1137+ def assertFileType(self, filename, filetype):
1138+ '''Checks the file type of the file specified'''
1139+
1140+ (rc, report, out) = self._testlib_shell_cmd(["/usr/bin/file", "-b", filename])
1141+ out = out.strip()
1142+ expected = 0
1143+ # Absolutely no idea why this happens on Hardy
1144+ if self.lsb_release['Release'] == 8.04 and rc == 255 and len(out) > 0:
1145+ rc = 0
1146+ result = 'Got exit code %d, expected %d:\n%s\n' % (rc, expected, report)
1147+ self.assertEquals(expected, rc, result)
1148+
1149+ filetype = '^%s$' % (filetype)
1150+ result = 'File type reported by file: [%s], expected regex: [%s]\n' % (out, filetype)
1151+ self.assertNotEquals(None, re.search(filetype, out), result)
1152+
1153+ def yank_commonname_from_cert(self, certfile):
1154+ '''Extract the commonName from a given PEM'''
1155+ rc, out = cmd(['openssl','asn1parse','-in',certfile])
1156+ if rc == 0:
1157+ ready = False
1158+ for line in out.splitlines():
1159+ if ready:
1160+ return line.split(':')[-1]
1161+ if ':commonName' in line:
1162+ ready = True
1163+ return socket.getfqdn()
1164+
1165+ def announce(self, text):
1166+ if self.my_verbosity:
1167+ print >>sys.stdout, "(%s) " % (text),
1168+ sys.stdout.flush()
1169+
1170+ def make_clean(self):
1171+ rc, output = self.shell_cmd(['make','clean'])
1172+ self.assertEquals(rc, 0, output)
1173+
1174+ def get_makefile_compiler(self):
1175+ # Find potential compiler name
1176+ compiler = 'gcc'
1177+ if os.path.exists('Makefile'):
1178+ for line in open('Makefile'):
1179+ if line.startswith('CC') and '=' in line:
1180+ items = [x.strip() for x in line.split('=')]
1181+ if items[0] == 'CC':
1182+ compiler = items[1]
1183+ break
1184+ return compiler
1185+
1186+ def make_target(self, target, expected=0):
1187+ '''Compile a target and report output'''
1188+
1189+ compiler = self.get_makefile_compiler()
1190+ rc, output = self.shell_cmd(['make',target])
1191+ self.assertEquals(rc, expected, 'rc(%d)!=%d:\n' % (rc, expected) + output)
1192+ self.assertTrue('%s ' % (compiler) in output, 'Expected "%s":' % (compiler) + output)
1193+ return output
1194+
1195+ # call as return testlib.skipped()
1196+ def _skipped(self, reason=""):
1197+ '''Provide a visible way to indicate that a test was skipped'''
1198+ if reason != "":
1199+ reason = ': %s' % (reason)
1200+ self.announce("skipped%s" % (reason))
1201+ return False
1202+
1203+ def _testlib_shell_cmd(self,args,stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT):
1204+ argstr = "'" + "', '".join(args).strip() + "'"
1205+ rc, out = cmd(args,stdin=stdin,stdout=stdout,stderr=stderr)
1206+ report = 'Command: ' + argstr + '\nOutput:\n' + out
1207+ return rc, report, out
1208+
1209+ def shell_cmd(self, args, stdin=None):
1210+ return cmd(args,stdin=stdin)
1211+
1212+ def assertShellExitEquals(self, expected, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg=""):
1213+ '''Test a shell command matches a specific exit code'''
1214+ rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
1215+ result = 'Got exit code %d, expected %d\n' % (rc, expected)
1216+ self.assertEquals(expected, rc, msg + result + report)
1217+
1218+ def assertShellExitNotEquals(self, unwanted, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg=""):
1219+ '''Test a shell command doesn't match a specific exit code'''
1220+ rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
1221+ result = 'Got (unwanted) exit code %d\n' % rc
1222+ self.assertNotEquals(unwanted, rc, msg + result + report)
1223+
1224+ def assertShellOutputContains(self, text, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg="", invert=False):
1225+ '''Test a shell command contains a specific output'''
1226+ rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
1227+ result = 'Got exit code %d. Looking for text "%s"\n' % (rc, text)
1228+ if not invert:
1229+ self.assertTrue(text in out, msg + result + report)
1230+ else:
1231+ self.assertFalse(text in out, msg + result + report)
1232+
1233+ def assertShellOutputEquals(self, text, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg="", invert=False, expected=None):
1234+ '''Test a shell command matches a specific output'''
1235+ rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
1236+ result = 'Got exit code %d. Looking for exact text "%s" (%s)\n' % (rc, text, " ".join(args))
1237+ if not invert:
1238+ self.assertEquals(text, out, msg + result + report)
1239+ else:
1240+ self.assertNotEquals(text, out, msg + result + report)
1241+ if expected != None:
1242+ result = 'Got exit code %d. Expected %d (%s)\n' % (rc, expected, " ".join(args))
1243+ self.assertEquals(rc, expected, msg + result + report)
1244+
1245+ def _word_find(self, report, content, invert=False):
1246+ '''Check for a specific string'''
1247+ if invert:
1248+ warning = 'Found "%s"\n' % content
1249+ self.assertTrue(content not in report, warning + report)
1250+ else:
1251+ warning = 'Could not find "%s"\n' % content
1252+ self.assertTrue(content in report, warning + report)
1253+
1254+ def _test_sysctl_value(self, path, expected, msg=None, exists=True):
1255+ sysctl = '/proc/sys/%s' % (path)
1256+ self.assertEquals(exists, os.path.exists(sysctl), sysctl)
1257+ value = None
1258+ if exists:
1259+ value = int(file(sysctl).read())
1260+ report = "%s is not %d: %d" % (sysctl, expected, value)
1261+ if msg:
1262+ report += " (%s)" % (msg)
1263+ self.assertEquals(value, expected, report)
1264+ return value
1265+
1266+ def set_sysctl_value(self, path, desired):
1267+ sysctl = '/proc/sys/%s' % (path)
1268+ self.assertTrue(os.path.exists(sysctl),"%s does not exist" % (sysctl))
1269+ file(sysctl,'w').write(str(desired))
1270+ self._test_sysctl_value(path, desired)
1271+
1272+ def kernel_at_least(self, introduced):
1273+ return self.version_compare(self.kernel_version_ubuntu,
1274+ introduced) >= 0
1275+
1276+ def kernel_claims_cve_fixed(self, cve):
1277+ changelog = "/usr/share/doc/linux-image-%s/changelog.Debian.gz" % (self.kernel_version)
1278+ if os.path.exists(changelog):
1279+ for line in gzip.open(changelog):
1280+ if cve in line and not "revert" in line and not "Revert" in line:
1281+ return True
1282+ return False
1283+
1284+class TestGroup:
1285+ '''Create a temporary test group and remove it again in the dtor.'''
1286+
1287+ def __init__(self, group=None, lower=False):
1288+ '''Create a new group'''
1289+
1290+ self.group = None
1291+ if group:
1292+ if group_exists(group):
1293+ raise ValueError, 'group name already exists'
1294+ else:
1295+ while(True):
1296+ group = random_string(7,lower=lower)
1297+ if not group_exists(group):
1298+ break
1299+
1300+ assert subprocess.call(['groupadd',group]) == 0
1301+ self.group = group
1302+ g = grp.getgrnam(self.group)
1303+ self.gid = g[2]
1304+
1305+ def __del__(self):
1306+ '''Remove the created group.'''
1307+
1308+ if self.group:
1309+ rc, report = cmd(['groupdel', self.group])
1310+ assert rc == 0
1311+
1312+class TestUser:
1313+ '''Create a temporary test user and remove it again in the dtor.'''
1314+
1315+ def __init__(self, login=None, home=True, group=None, uidmin=None, lower=False, shell=None):
1316+ '''Create a new user account with a random password.
1317+
1318+ By default, the login name is random, too, but can be explicitly
1319+ specified with 'login'. By default, a home directory is created, this
1320+ can be suppressed with 'home=False'.'''
1321+
1322+ self.login = None
1323+
1324+ if os.geteuid() != 0:
1325+ raise ValueError, "You must be root to run this test"
1326+
1327+ if login:
1328+ if login_exists(login):
1329+ raise ValueError, 'login name already exists'
1330+ else:
1331+ while(True):
1332+ login = 't' + random_string(7,lower=lower)
1333+ if not login_exists(login):
1334+ break
1335+
1336+ self.salt = random_string(2)
1337+ self.password = random_string(8,lower=lower)
1338+ self.crypted = crypt.crypt(self.password, self.salt)
1339+
1340+ creation = ['useradd', '-p', self.crypted]
1341+ if home:
1342+ creation += ['-m']
1343+ if group:
1344+ creation += ['-G',group]
1345+ if uidmin:
1346+ creation += ['-K','UID_MIN=%d'%uidmin]
1347+ if shell:
1348+ creation += ['-s',shell]
1349+ creation += [login]
1350+ assert subprocess.call(creation) == 0
1351+ # Set GECOS
1352+ assert subprocess.call(['usermod','-c','Buddy %s' % (login),login]) == 0
1353+
1354+ self.login = login
1355+ p = pwd.getpwnam(self.login)
1356+ self.uid = p[2]
1357+ self.gid = p[3]
1358+ self.gecos = p[4]
1359+ self.home = p[5]
1360+ self.shell = p[6]
1361+
1362+ def __del__(self):
1363+ '''Remove the created user account.'''
1364+
1365+ if self.login:
1366+ # sanity check the login name so we don't accidentally wipe too much
1367+ if len(self.login)>3 and not '/' in self.login:
1368+ subprocess.call(['rm','-rf', '/home/'+self.login, '/var/mail/'+self.login])
1369+ rc, report = cmd(['userdel', '-f', self.login])
1370+ assert rc == 0
1371+
1372+ def add_to_group(self, group):
1373+ '''Add user to the specified group name'''
1374+ rc, report = cmd(['usermod', '-G', group, self.login])
1375+ if rc != 0:
1376+ print report
1377+ assert rc == 0
1378+
1379+# Timeout handler using alarm() from John P. Speno's Pythonic Avocado
1380+class TimeoutFunctionException(Exception):
1381+ """Exception to raise on a timeout"""
1382+ pass
1383+class TimeoutFunction:
1384+ def __init__(self, function, timeout):
1385+ self.timeout = timeout
1386+ self.function = function
1387+
1388+ def handle_timeout(self, signum, frame):
1389+ raise TimeoutFunctionException()
1390+
1391+ def __call__(self, *args, **kwargs):
1392+ old = signal.signal(signal.SIGALRM, self.handle_timeout)
1393+ signal.alarm(self.timeout)
1394+ try:
1395+ result = self.function(*args, **kwargs)
1396+ finally:
1397+ signal.signal(signal.SIGALRM, old)
1398+ signal.alarm(0)
1399+ return result
1400+
1401+def main():
1402+ print "hi"
1403+ unittest.main()
1404
1405=== added file 'debian/tests/testsuite'
1406--- debian/tests/testsuite 1970-01-01 00:00:00 +0000
1407+++ debian/tests/testsuite 2013-05-17 10:06:26 +0000
1408@@ -0,0 +1,7 @@
1409+#!/bin/bash
1410+#-------------------
1411+# Testing open-iscsi
1412+#-------------------
1413+set -e
1414+python `dirname $0`/test-open-iscsi.py 2>&1
1415+

Subscribers

People subscribed via source and target branches

to all changes: