/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: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

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
28
28
 
29
29
__all__ = [
30
30
    'HasLayout',
31
 
    'HasPathRelations',
32
31
    'MatchesAncestry',
33
32
    'ContainsNoVfsCalls',
34
33
    'ReturnsUnlockable',
35
34
    'RevisionHistoryMatches',
36
35
    ]
37
36
 
38
 
from .. import (
 
37
from bzrlib import (
39
38
    osutils,
40
39
    revision as _mod_revision,
41
40
    )
42
 
from .. import lazy_import
 
41
from bzrlib import lazy_import
43
42
lazy_import.lazy_import(globals(),
44
43
"""
45
 
from breezy.bzr.smart.request import request_handlers as smart_request_handlers
46
 
from breezy.bzr.smart import vfs
 
44
from bzrlib.smart.request import request_handlers as smart_request_handlers
 
45
from bzrlib.smart import vfs
47
46
""")
48
 
from ..sixish import (
49
 
    text_type,
50
 
    )
51
 
from ..tree import find_previous_path
52
47
 
53
48
from testtools.matchers import Equals, Mismatch, Matcher
54
49
 
118
113
            self.repository, self.revision_id))
119
114
 
120
115
    def match(self, expected):
121
 
        with self.repository.lock_read():
 
116
        self.repository.lock_read()
 
117
        try:
122
118
            graph = self.repository.get_graph()
123
119
            got = [r for r, p in graph.iter_ancestry([self.revision_id])]
124
120
            if _mod_revision.NULL_REVISION in got:
125
121
                got.remove(_mod_revision.NULL_REVISION)
 
122
        finally:
 
123
            self.repository.unlock()
126
124
        if sorted(got) != sorted(expected):
127
125
            return _AncestryMismatch(self.revision_id, sorted(got),
128
126
                sorted(expected))
140
138
 
141
139
    def get_tree_layout(self, tree):
142
140
        """Get the (path, file_id) pairs for the current tree."""
143
 
        with tree.lock_read():
 
141
        tree.lock_read()
 
142
        try:
144
143
            for path, ie in tree.iter_entries_by_dir():
145
144
                if ie.parent_id is None:
146
145
                    yield (u"", ie.file_id)
147
146
                else:
148
147
                    yield (path+ie.kind_character(), ie.file_id)
 
148
        finally:
 
149
            tree.unlock()
149
150
 
150
151
    @staticmethod
151
152
    def _strip_unreferenced_directories(entries):
155
156
        """
156
157
        directories = []
157
158
        for entry in entries:
158
 
            if isinstance(entry, (str, text_type)):
 
159
            if isinstance(entry, basestring):
159
160
                path = entry
160
161
            else:
161
162
                path = entry[0]
175
176
 
176
177
    def match(self, tree):
177
178
        actual = list(self.get_tree_layout(tree))
178
 
        if self.entries and isinstance(self.entries[0], (str, text_type)):
 
179
        if self.entries and isinstance(self.entries[0], basestring):
179
180
            actual = [path for (path, fileid) in actual]
180
181
        if not tree.has_versioned_directories():
181
182
            entries = list(self._strip_unreferenced_directories(self.entries))
184
185
        return Equals(entries).match(actual)
185
186
 
186
187
 
187
 
class HasPathRelations(Matcher):
188
 
    """Matcher verifies that paths have a relation to those in another tree.
189
 
 
190
 
    :ivar previous_tree: tree to compare to
191
 
    :ivar previous_entries: List of expected entries, as (path, previous_path) pairs.
192
 
    """
193
 
 
194
 
    def __init__(self, previous_tree, previous_entries):
195
 
        Matcher.__init__(self)
196
 
        self.previous_tree = previous_tree
197
 
        self.previous_entries = previous_entries
198
 
 
199
 
    def get_path_map(self, tree):
200
 
        """Get the (path, previous_path) pairs for the current tree."""
201
 
        with tree.lock_read(), self.previous_tree.lock_read():
202
 
            for path, ie in tree.iter_entries_by_dir():
203
 
                if tree.supports_rename_tracking():
204
 
                    previous_path = find_previous_path(tree, self.previous_tree, path)
205
 
                else:
206
 
                    if self.previous_tree.is_versioned(path):
207
 
                        previous_path = path
208
 
                    else:
209
 
                        previous_path = None
210
 
                if previous_path:
211
 
                    kind = self.previous_tree.kind(previous_path)
212
 
                    if kind == 'directory':
213
 
                        previous_path += '/'
214
 
                if ie.parent_id is None:
215
 
                    yield (u"", previous_path)
216
 
                else:
217
 
                    yield (path+ie.kind_character(), previous_path)
218
 
 
219
 
    @staticmethod
220
 
    def _strip_unreferenced_directories(entries):
221
 
        """Strip all directories that don't (in)directly contain any files.
222
 
 
223
 
        :param entries: List of path strings or (path, previous_path) tuples to process
224
 
        """
225
 
        directory_used = set()
226
 
        directories = []
227
 
        for (path, previous_path) in entries:
228
 
            if not path or path[-1] == "/":
229
 
                # directory
230
 
                directories.append((path, previous_path))
231
 
            else:
232
 
                # Yield the referenced parent directories
233
 
                for direntry in directories:
234
 
                    if osutils.is_inside(direntry[0], path):
235
 
                        directory_used.add(direntry[0])
236
 
        for (path, previous_path) in entries:
237
 
            if (not path.endswith("/")) or path in directory_used:
238
 
                yield (path, previous_path)
239
 
 
240
 
    def __str__(self):
241
 
        return 'HasPathRelations(%r, %r)' % (self.previous_tree, self.previous_entries)
242
 
 
243
 
    def match(self, tree):
244
 
        actual = list(self.get_path_map(tree))
245
 
        if not tree.has_versioned_directories():
246
 
            entries = list(self._strip_unreferenced_directories(self.previous_entries))
247
 
        else:
248
 
            entries = self.previous_entries
249
 
        if not tree.supports_rename_tracking():
250
 
            entries = [
251
 
                (path, path if self.previous_tree.is_versioned(path) else None)
252
 
                for (path, previous_path) in entries]
253
 
        return Equals(entries).match(actual)
254
 
 
255
 
 
256
188
class RevisionHistoryMatches(Matcher):
257
189
    """A matcher that checks if a branch has a specific revision history.
258
190
 
267
199
        return 'RevisionHistoryMatches(%r)' % self.expected
268
200
 
269
201
    def match(self, branch):
270
 
        with branch.lock_read():
 
202
        branch.lock_read()
 
203
        try:
271
204
            graph = branch.repository.get_graph()
272
205
            history = list(graph.iter_lefthand_ancestry(
273
206
                branch.last_revision(), [_mod_revision.NULL_REVISION]))
274
207
            history.reverse()
 
208
        finally:
 
209
            branch.unlock()
275
210
        return Equals(self.expected).match(history)
276
211
 
277
212