s4:dsdb/acl_read: enable acl checking on search by default (bug #8620)
[nivanova/samba-autobuild/.git] / selftest / testlist.py
1 # testlist.py -- Test list
2 # Copyright (C) 2012 Jelmer Vernooij <jelmer@samba.org>
3 #
4 # This program is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU General Public License
6 # as published by the Free Software Foundation; version 3
7 # of the License or (at your option) any later version of
8 # the License.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
18 # MA  02110-1301, USA.
19
20 """Selftest test list management."""
21
22 __all__ = ['find_in_list', 'read_test_regexes', 'read_testlist']
23
24 import os
25 import re
26 import sys
27
28 def find_in_list(list, fullname):
29     """Find test in list.
30
31     :param list: List with 2-tuples with regex and reason
32     """
33     for (regex, reason) in list:
34         if re.match(regex, fullname):
35             if reason is not None:
36                 return reason
37             else:
38                 return ""
39     return None
40
41
42 def read_test_regexes(f):
43     """Read tuples with regular expression and optional string from a file.
44
45     :param f: File-like object to read from
46     :return: Iterator over tuples with regular expression and test name
47     """
48     for l in f.readlines():
49         l = l.strip()
50         if l[0] == "#":
51             continue
52         try:
53             (test, reason) = l.split("#", 1)
54         except ValueError:
55             yield l, None
56         else:
57             yield test.strip(), reason.strip()
58
59
60 def should_run_test(tests, name):
61     if tests == []:
62         return True
63     for test in tests:
64         if re.match(test, name):
65             return True
66     return False
67
68
69 def read_testlist(inf, outf):
70     """Read a list of tests from a file.
71
72     :param inf: File-like object to read from.
73     :param outf: File-like object to write to.
74     :return: Iterator over tuples describing tests
75     """
76     while True:
77         l = inf.readline()
78         if l == '':
79             return
80         if l.startswith("-- TEST") and l.endswith(" --\n"):
81             supports_loadlist = l.startswith("-- TEST-LOADLIST")
82             supports_idlist = l.startswith("-- TEST-IDLIST")
83             name = inf.readline().rstrip("\n")
84             env = inf.readline().rstrip("\n")
85             cmdline = inf.readline().rstrip("\n")
86             yield (name, env, cmdline, supports_loadlist, supports_idlist)
87         else:
88             outf.write(l)
89
90
91 def read_restricted_test_list(f):
92     for l in f.readlines():
93         yield l.strip()
94
95
96 class RestrictedTestManager(object):
97     """Test manager which can filter individual tests that should be run."""
98
99     def __init__(self, test_list):
100         self.test_list = test_list
101         self.unused = set(self.test_list)
102
103     @classmethod
104     def from_path(cls, path):
105         f = open(path, 'r')
106         try:
107             return cls(read_restricted_test_list(f))
108         finally:
109             f.close()
110
111     def should_run_testsuite(self, name):
112         """Determine whether a testsuite should be run.
113
114         :param name: Name of the testsuite
115         :return: None if full testsuite should be run,
116             a list of subtests to run or [] if it should
117             not be run.
118         """
119         match = []
120         for r in self.test_list:
121             if r == name:
122                 match = None
123                 if r in self.unused:
124                     self.unused.remove(r)
125             elif r.startswith(name + "."):
126                 if match is not None:
127                     match.append(r[len(name+"."):])
128                 if r in self.unused:
129                     self.unused.remove(r)
130         return match
131
132     def iter_unused(self):
133         """Iterate over entry entries that were unused.
134
135         :return: Iterator over test list entries that were not used.
136         """
137         return iter(self.unused)
138
139
140 def open_file_or_pipe(path, mode):
141     """Open a file or pipe.
142
143     :param path: Path to open; if it ends with | it is assumed to be a
144         command to run
145     :param mode: Mode with which to open it
146     :return: File-like object
147     """
148     if path.endswith("|"):
149         return os.popen(path[:-1], mode)
150     return open(path, mode)
151
152
153 def read_testlist_file(fn, outf=None):
154     """Read testlist file.
155
156     :param fn: Path to read (assumed to be a command to run if it ends with |)
157     :param outf: File-like object to pass non-test data through to
158         (defaults to stdout)
159     :return: Iterator over test suites (see read_testlist)
160     """
161     if outf is None:
162         outf = sys.stdout
163     inf = open_file_or_pipe(fn, 'r')
164     try:
165         for testsuite in read_testlist(inf, outf):
166             yield testsuite
167     finally:
168         inf.close()