/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/matchers.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/matchers.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Matchers for breezy.
 
17
"""Matchers for bzrlib.
18
18
 
19
 
Primarily test support, Matchers are used by self.assertThat in the breezy
 
19
Primarily test support, Matchers are used by self.assertThat in the bzrlib
20
20
test suite. A matcher is a stateful test helper which can be used to determine
21
21
if a passed object 'matches', much like a regex. If the object does not match
22
22
the mismatch can be described in a human readable fashion. assertThat then
27
27
"""
28
28
 
29
29
__all__ = [
30
 
    'HasLayout',
31
 
    'HasPathRelations',
32
 
    'MatchesAncestry',
33
 
    'ContainsNoVfsCalls',
34
30
    'ReturnsUnlockable',
35
 
    'RevisionHistoryMatches',
36
31
    ]
37
32
 
38
 
from .. import (
39
 
    osutils,
40
 
    revision as _mod_revision,
41
 
    )
42
 
from .. import lazy_import
43
 
lazy_import.lazy_import(globals(),
44
 
"""
45
 
from breezy.bzr.smart.request import request_handlers as smart_request_handlers
46
 
from breezy.bzr.smart import vfs
47
 
""")
48
 
from ..sixish import (
49
 
    text_type,
50
 
    )
51
 
from ..tree import find_previous_path
52
 
 
53
 
from testtools.matchers import Equals, Mismatch, Matcher
 
33
from testtools.matchers import Mismatch, Matcher
54
34
 
55
35
 
56
36
class ReturnsUnlockable(Matcher):
68
48
        self.lockable_thing = lockable_thing
69
49
 
70
50
    def __str__(self):
71
 
        return ('ReturnsUnlockable(lockable_thing=%s)' %
 
51
        return ('ReturnsUnlockable(lockable_thing=%s)' % 
72
52
            self.lockable_thing)
73
53
 
74
54
    def match(self, lock_method):
86
66
 
87
67
    def describe(self):
88
68
        return "%s is locked" % self.lockable_thing
89
 
 
90
 
 
91
 
class _AncestryMismatch(Mismatch):
92
 
    """Ancestry matching mismatch."""
93
 
 
94
 
    def __init__(self, tip_revision, got, expected):
95
 
        self.tip_revision = tip_revision
96
 
        self.got = got
97
 
        self.expected = expected
98
 
 
99
 
    def describe(self):
100
 
        return "mismatched ancestry for revision %r was %r, expected %r" % (
101
 
            self.tip_revision, self.got, self.expected)
102
 
 
103
 
 
104
 
class MatchesAncestry(Matcher):
105
 
    """A matcher that checks the ancestry of a particular revision.
106
 
 
107
 
    :ivar graph: Graph in which to check the ancestry
108
 
    :ivar revision_id: Revision id of the revision
109
 
    """
110
 
 
111
 
    def __init__(self, repository, revision_id):
112
 
        Matcher.__init__(self)
113
 
        self.repository = repository
114
 
        self.revision_id = revision_id
115
 
 
116
 
    def __str__(self):
117
 
        return ('MatchesAncestry(repository=%r, revision_id=%r)' % (
118
 
            self.repository, self.revision_id))
119
 
 
120
 
    def match(self, expected):
121
 
        with self.repository.lock_read():
122
 
            graph = self.repository.get_graph()
123
 
            got = [r for r, p in graph.iter_ancestry([self.revision_id])]
124
 
            if _mod_revision.NULL_REVISION in got:
125
 
                got.remove(_mod_revision.NULL_REVISION)
126
 
        if sorted(got) != sorted(expected):
127
 
            return _AncestryMismatch(self.revision_id, sorted(got),
128
 
                sorted(expected))
129
 
 
130
 
 
131
 
class HasLayout(Matcher):
132
 
    """A matcher that checks if a tree has a specific layout.
133
 
 
134
 
    :ivar entries: List of expected entries, as (path, file_id) pairs.
135
 
    """
136
 
 
137
 
    def __init__(self, entries):
138
 
        Matcher.__init__(self)
139
 
        self.entries = entries
140
 
 
141
 
    def get_tree_layout(self, tree, include_file_ids):
142
 
        """Get the (path, file_id) pairs for the current tree."""
143
 
        with tree.lock_read():
144
 
            for path, ie in tree.iter_entries_by_dir():
145
 
                if path != u'':
146
 
                    path += ie.kind_character()
147
 
                if include_file_ids:
148
 
                    yield (path, ie.file_id)
149
 
                else:
150
 
                    yield path
151
 
 
152
 
    @staticmethod
153
 
    def _strip_unreferenced_directories(entries):
154
 
        """Strip all directories that don't (in)directly contain any files.
155
 
 
156
 
        :param entries: List of path strings or (path, ie) tuples to process
157
 
        """
158
 
        directories = []
159
 
        for entry in entries:
160
 
            if isinstance(entry, (str, text_type)):
161
 
                path = entry
162
 
            else:
163
 
                path = entry[0]
164
 
            if not path or path[-1] == "/":
165
 
                # directory
166
 
                directories.append((path, entry))
167
 
            else:
168
 
                # Yield the referenced parent directories
169
 
                for dirpath, direntry in directories:
170
 
                    if osutils.is_inside(dirpath, path):
171
 
                        yield direntry
172
 
                directories = []
173
 
                yield entry
174
 
 
175
 
    def __str__(self):
176
 
        return 'HasLayout(%r)' % self.entries
177
 
 
178
 
    def match(self, tree):
179
 
        include_file_ids = self.entries and not isinstance(self.entries[0], (str, text_type))
180
 
        actual = list(self.get_tree_layout(tree, include_file_ids=include_file_ids))
181
 
        if not tree.has_versioned_directories():
182
 
            entries = list(self._strip_unreferenced_directories(self.entries))
183
 
        else:
184
 
            entries = self.entries
185
 
        return Equals(entries).match(actual)
186
 
 
187
 
 
188
 
class HasPathRelations(Matcher):
189
 
    """Matcher verifies that paths have a relation to those in another tree.
190
 
 
191
 
    :ivar previous_tree: tree to compare to
192
 
    :ivar previous_entries: List of expected entries, as (path, previous_path) pairs.
193
 
    """
194
 
 
195
 
    def __init__(self, previous_tree, previous_entries):
196
 
        Matcher.__init__(self)
197
 
        self.previous_tree = previous_tree
198
 
        self.previous_entries = previous_entries
199
 
 
200
 
    def get_path_map(self, tree):
201
 
        """Get the (path, previous_path) pairs for the current tree."""
202
 
        with tree.lock_read(), self.previous_tree.lock_read():
203
 
            for path, ie in tree.iter_entries_by_dir():
204
 
                if tree.supports_rename_tracking():
205
 
                    previous_path = find_previous_path(tree, self.previous_tree, path)
206
 
                else:
207
 
                    if self.previous_tree.is_versioned(path):
208
 
                        previous_path = path
209
 
                    else:
210
 
                        previous_path = None
211
 
                if previous_path:
212
 
                    kind = self.previous_tree.kind(previous_path)
213
 
                    if kind == 'directory':
214
 
                        previous_path += '/'
215
 
                if path == u'':
216
 
                    yield (u"", previous_path)
217
 
                else:
218
 
                    yield (path+ie.kind_character(), previous_path)
219
 
 
220
 
    @staticmethod
221
 
    def _strip_unreferenced_directories(entries):
222
 
        """Strip all directories that don't (in)directly contain any files.
223
 
 
224
 
        :param entries: List of path strings or (path, previous_path) tuples to process
225
 
        """
226
 
        directory_used = set()
227
 
        directories = []
228
 
        for (path, previous_path) in entries:
229
 
            if not path or path[-1] == "/":
230
 
                # directory
231
 
                directories.append((path, previous_path))
232
 
            else:
233
 
                # Yield the referenced parent directories
234
 
                for direntry in directories:
235
 
                    if osutils.is_inside(direntry[0], path):
236
 
                        directory_used.add(direntry[0])
237
 
        for (path, previous_path) in entries:
238
 
            if (not path.endswith("/")) or path in directory_used:
239
 
                yield (path, previous_path)
240
 
 
241
 
    def __str__(self):
242
 
        return 'HasPathRelations(%r, %r)' % (self.previous_tree, self.previous_entries)
243
 
 
244
 
    def match(self, tree):
245
 
        actual = list(self.get_path_map(tree))
246
 
        if not tree.has_versioned_directories():
247
 
            entries = list(self._strip_unreferenced_directories(self.previous_entries))
248
 
        else:
249
 
            entries = self.previous_entries
250
 
        if not tree.supports_rename_tracking():
251
 
            entries = [
252
 
                (path, path if self.previous_tree.is_versioned(path) else None)
253
 
                for (path, previous_path) in entries]
254
 
        return Equals(entries).match(actual)
255
 
 
256
 
 
257
 
class RevisionHistoryMatches(Matcher):
258
 
    """A matcher that checks if a branch has a specific revision history.
259
 
 
260
 
    :ivar history: Revision history, as list of revisions. Oldest first.
261
 
    """
262
 
 
263
 
    def __init__(self, history):
264
 
        Matcher.__init__(self)
265
 
        self.expected = history
266
 
 
267
 
    def __str__(self):
268
 
        return 'RevisionHistoryMatches(%r)' % self.expected
269
 
 
270
 
    def match(self, branch):
271
 
        with branch.lock_read():
272
 
            graph = branch.repository.get_graph()
273
 
            history = list(graph.iter_lefthand_ancestry(
274
 
                branch.last_revision(), [_mod_revision.NULL_REVISION]))
275
 
            history.reverse()
276
 
        return Equals(self.expected).match(history)
277
 
 
278
 
 
279
 
class _NoVfsCallsMismatch(Mismatch):
280
 
    """Mismatch describing a list of HPSS calls which includes VFS requests."""
281
 
 
282
 
    def __init__(self, vfs_calls):
283
 
        self.vfs_calls = vfs_calls
284
 
 
285
 
    def describe(self):
286
 
        return "no VFS calls expected, got: %s" % ",".join([
287
 
            "%s(%s)" % (c.method,
288
 
                ", ".join([repr(a) for a in c.args])) for c in self.vfs_calls])
289
 
 
290
 
 
291
 
class ContainsNoVfsCalls(Matcher):
292
 
    """Ensure that none of the specified calls are HPSS calls."""
293
 
 
294
 
    def __str__(self):
295
 
        return 'ContainsNoVfsCalls()'
296
 
 
297
 
    @classmethod
298
 
    def match(cls, hpss_calls):
299
 
        vfs_calls = []
300
 
        for call in hpss_calls:
301
 
            try:
302
 
                request_method = smart_request_handlers.get(call.call.method)
303
 
            except KeyError:
304
 
                # A method we don't know about doesn't count as a VFS method.
305
 
                continue
306
 
            if issubclass(request_method, vfs.VfsRequest):
307
 
                vfs_calls.append(call.call)
308
 
        if len(vfs_calls) == 0:
309
 
            return None
310
 
        return _NoVfsCallsMismatch(vfs_calls)