← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_tree/__init__.py

  • Committer: Andrew Bennetts
  • Date: 2010-01-12 03:53:21 UTC
  • mfrom: (4948 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4964.
  • Revision ID: andrew.bennetts@canonical.com-20100112035321-hofpz5p10224ryj3
Merge lp:bzr, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_tree/__init__.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
18
"""Tree implementation tests for bzr.
19
19
 
20
20
These test the conformance of all the tree variations to the expected API.
21
21
Specific tests for individual variations are in other places such as:
 
22
 - tests/per_workingtree/*.py.
22
23
 - tests/test_tree.py
23
24
 - tests/test_revision.py
24
25
 - tests/test_workingtree.py
25
 
 - tests/workingtree_implementations/*.py.
26
26
"""
27
27
 
28
28
from bzrlib import (
32
32
    tests,
33
33
    transform,
34
34
    )
35
 
from bzrlib.transport import get_transport
36
 
from bzrlib.tests import (
37
 
                          adapt_modules,
38
 
                          default_transport,
39
 
                          TestCaseWithTransport,
40
 
                          TestSkipped,
41
 
                          )
42
 
from bzrlib.tests.bzrdir_implementations.test_bzrdir import TestCaseWithBzrDir
43
 
from bzrlib.tests.workingtree_implementations import (
44
 
    WorkingTreeTestProviderAdapter,
 
35
from bzrlib.tests.per_bzrdir.test_bzrdir import TestCaseWithBzrDir
 
36
from bzrlib.tests.per_workingtree import (
 
37
    make_scenarios as wt_make_scenarios,
 
38
    make_scenario as wt_make_scenario,
45
39
    )
46
40
from bzrlib.revision import NULL_REVISION
47
41
from bzrlib.revisiontree import RevisionTree
96
90
    return preview_tree
97
91
 
98
92
 
99
 
class TestTreeImplementationSupport(TestCaseWithTransport):
 
93
class TestTreeImplementationSupport(tests.TestCaseWithTransport):
100
94
 
101
95
    def test_revision_tree_from_workingtree(self):
102
96
        tree = self.make_branch_and_tree('.')
125
119
 
126
120
    def get_tree_no_parents_no_content(self, empty_tree, converter=None):
127
121
        """Make a tree with no parents and no contents from empty_tree.
128
 
        
 
122
 
129
123
        :param empty_tree: A working tree with no content and no parents to
130
124
            modify.
131
125
        """
147
141
 
148
142
    def get_tree_no_parents_abc_content_2(self, tree, converter=None):
149
143
        """return a test tree with a, b/, b/c contents.
150
 
        
 
144
 
151
145
        This variation changes the content of 'a' to foobar\n.
152
146
        """
153
147
        self._make_abc_tree(tree)
160
154
 
161
155
    def get_tree_no_parents_abc_content_3(self, tree, converter=None):
162
156
        """return a test tree with a, b/, b/c contents.
163
 
        
 
157
 
164
158
        This variation changes the executable flag of b/c to True.
165
159
        """
166
160
        self._make_abc_tree(tree)
172
166
 
173
167
    def get_tree_no_parents_abc_content_4(self, tree, converter=None):
174
168
        """return a test tree with d, b/, b/c contents.
175
 
        
 
169
 
176
170
        This variation renames a to d.
177
171
        """
178
172
        self._make_abc_tree(tree)
181
175
 
182
176
    def get_tree_no_parents_abc_content_5(self, tree, converter=None):
183
177
        """return a test tree with d, b/, b/c contents.
184
 
        
 
178
 
185
179
        This variation renames a to d and alters its content to 'bar\n'.
186
180
        """
187
181
        self._make_abc_tree(tree)
195
189
 
196
190
    def get_tree_no_parents_abc_content_6(self, tree, converter=None):
197
191
        """return a test tree with a, b/, e contents.
198
 
        
 
192
 
199
193
        This variation renames b/c to e, and makes it executable.
200
194
        """
201
195
        self._make_abc_tree(tree)
207
201
        tt.apply()
208
202
        return self._convert_tree(tree, converter)
209
203
 
 
204
    def get_tree_no_parents_abc_content_7(self, tree, converter=None):
 
205
        """return a test tree with a, b/, d/e contents.
 
206
 
 
207
        This variation adds a dir 'd' ('d-id'), renames b to d/e.
 
208
        """
 
209
        self._make_abc_tree(tree)
 
210
        self.build_tree(['d/'], transport=tree.bzrdir.root_transport)
 
211
        tree.add(['d'], ['d-id'])
 
212
        tt = transform.TreeTransform(tree)
 
213
        trans_id = tt.trans_id_tree_path('b')
 
214
        parent_trans_id = tt.trans_id_tree_path('d')
 
215
        tt.adjust_path('e', parent_trans_id, trans_id)
 
216
        tt.apply()
 
217
        return self._convert_tree(tree, converter)
 
218
 
210
219
    def get_tree_with_subdirs_and_all_content_types(self):
211
220
        """Return a test tree with subdirs and all content types.
212
221
        See get_tree_with_subdirs_and_all_supported_content_types for details.
235
244
        where each component has the type of its name -
236
245
        i.e. '1file..' is afile.
237
246
 
238
 
        note that the order of the paths and fileids is deliberately 
 
247
        note that the order of the paths and fileids is deliberately
239
248
        mismatched to ensure that the result order is path based.
240
249
        """
 
250
        self.requireFeature(tests.UnicodeFilenameFeature)
241
251
        tree = self.make_branch_and_tree('.')
242
252
        paths = ['0file',
243
253
            '1top-dir/',
252
262
            '1file-in-1topdir',
253
263
            '0dir-in-1topdir'
254
264
            ]
255
 
        try:
256
 
            self.build_tree(paths)
257
 
        except UnicodeError:
258
 
            raise TestSkipped(
259
 
                'This platform does not support unicode file paths.')
 
265
        self.build_tree(paths)
260
266
        tree.add(paths, ids)
261
267
        tt = transform.TreeTransform(tree)
262
268
        if symlinks:
273
279
 
274
280
    def _create_tree_with_utf8(self, tree):
275
281
        """Generate a tree with a utf8 revision and unicode paths."""
 
282
        self.requireFeature(tests.UnicodeFilenameFeature)
276
283
        # We avoid combining characters in file names here, normalization
277
284
        # checks (as performed by some file systems (OSX) are outside the scope
278
285
        # of these tests).  We use the euro sign \N{Euro Sign} or \u20ac in
289
296
                    'ba\xe2\x82\xacr-id',
290
297
                    'ba\xe2\x82\xacz-id',
291
298
                   ]
292
 
        try:
293
 
            self.build_tree(paths[1:])
294
 
        except UnicodeError:
295
 
            raise tests.TestSkipped('filesystem does not support unicode.')
 
299
        self.build_tree(paths[1:])
296
300
        if tree.get_root_id() is None:
297
301
            # Some trees do not have a root yet.
298
302
            tree.add(paths, file_ids)
319
323
        return self.workingtree_to_test_tree(tree)
320
324
 
321
325
 
322
 
class TreeTestProviderAdapter(WorkingTreeTestProviderAdapter):
 
326
def make_scenarios(transport_server, transport_readonly_server, formats):
323
327
    """Generate test suites for each Tree implementation in bzrlib.
324
328
 
325
329
    Currently this covers all working tree formats, and RevisionTree and
326
330
    DirStateRevisionTree by committing a working tree to create the revision
327
331
    tree.
328
332
    """
329
 
 
330
 
    def __init__(self, transport_server, transport_readonly_server, formats):
331
 
        """Create a TreeTestProviderAdapter.
332
 
 
333
 
        :param formats: [workingtree_format]
334
 
        """
335
 
        super(TreeTestProviderAdapter, self).__init__(transport_server,
336
 
            transport_readonly_server, formats)
337
 
        # now adjust the scenarios and add the non-working-tree tree scenarios.
338
 
        for scenario in self.scenarios:
339
 
            # for working tree adapted tests, preserve the tree
340
 
            scenario[1]["_workingtree_to_test_tree"] = return_parameter
341
 
        # add RevisionTree scenario
342
 
        self.scenarios.append(self.create_tree_scenario(RevisionTree.__name__,
343
 
                              revision_tree_from_workingtree,))
344
 
 
345
 
        # also test WorkingTree4's RevisionTree implementation which is
346
 
        # specialised.
347
 
        self.scenarios.append(self.create_tree_scenario(
348
 
            DirStateRevisionTree.__name__, _dirstate_tree_from_workingtree,
349
 
            WorkingTreeFormat4()))
350
 
        self.scenarios.append(self.create_tree_scenario(
351
 
            DirStateRevisionTree.__name__, _dirstate_tree_from_workingtree,
352
 
            WorkingTreeFormat5()))
353
 
        self.scenarios.append(self.create_tree_scenario('PreviewTree',
354
 
            preview_tree_pre))
355
 
        self.scenarios.append(self.create_tree_scenario('PreviewTreePost',
356
 
            preview_tree_post))
357
 
 
358
 
    def create_tree_scenario(self, name, converter, workingtree_format=None):
359
 
        """Create a scenario for the specified converter
360
 
 
361
 
        :param name: The name to append to tests using this converter
362
 
        :param converter: A function that converts a workingtree into the
363
 
            desired format.
364
 
        :param workingtree_format: The particular workingtree format to
365
 
            convert from.
366
 
        :return: a (name, options) tuple, where options is a dict of values
367
 
            to be used as members of the TestCase.
368
 
        """
369
 
        if workingtree_format is None:
370
 
            workingtree_format = WorkingTreeFormat._default_format
371
 
        scenario_options = WorkingTreeTestProviderAdapter.create_scenario(self,
372
 
            workingtree_format)[1]
373
 
        scenario_options["_workingtree_to_test_tree"] = converter
374
 
        return name, scenario_options
375
 
 
376
 
 
377
 
def load_tests(basic_tests, module, loader):
378
 
    result = loader.suiteClass()
379
 
    # add the tests for this module
380
 
    result.addTests(basic_tests)
381
 
 
382
 
    test_tree_implementations = [
383
 
        'bzrlib.tests.tree_implementations.test_annotate_iter',
384
 
        'bzrlib.tests.tree_implementations.test_get_file_mtime',
385
 
        'bzrlib.tests.tree_implementations.test_get_root_id',
386
 
        'bzrlib.tests.tree_implementations.test_get_symlink_target',
387
 
        'bzrlib.tests.tree_implementations.test_inv',
388
 
        'bzrlib.tests.tree_implementations.test_iter_search_rules',
389
 
        'bzrlib.tests.tree_implementations.test_list_files',
390
 
        'bzrlib.tests.tree_implementations.test_path_content_summary',
391
 
        'bzrlib.tests.tree_implementations.test_revision_tree',
392
 
        'bzrlib.tests.tree_implementations.test_test_trees',
393
 
        'bzrlib.tests.tree_implementations.test_tree',
394
 
        'bzrlib.tests.tree_implementations.test_walkdirs',
 
333
    scenarios = wt_make_scenarios(transport_server, transport_readonly_server,
 
334
        formats)
 
335
    # now adjust the scenarios and add the non-working-tree tree scenarios.
 
336
    for scenario in scenarios:
 
337
        # for working tree format tests, preserve the tree
 
338
        scenario[1]["_workingtree_to_test_tree"] = return_parameter
 
339
    # add RevisionTree scenario
 
340
    workingtree_format = WorkingTreeFormat._default_format
 
341
    scenarios.append((RevisionTree.__name__,
 
342
        create_tree_scenario(transport_server, transport_readonly_server,
 
343
        workingtree_format, revision_tree_from_workingtree,)))
 
344
 
 
345
    # also test WorkingTree4/5's RevisionTree implementation which is
 
346
    # specialised.
 
347
    # XXX: Ask igc if WT5 revision tree actually is different.
 
348
    scenarios.append((DirStateRevisionTree.__name__ + ",WT4",
 
349
        create_tree_scenario(transport_server, transport_readonly_server,
 
350
        WorkingTreeFormat4(), _dirstate_tree_from_workingtree)))
 
351
    scenarios.append((DirStateRevisionTree.__name__ + ",WT5",
 
352
        create_tree_scenario(transport_server, transport_readonly_server,
 
353
        WorkingTreeFormat5(), _dirstate_tree_from_workingtree)))
 
354
    scenarios.append(("PreviewTree", create_tree_scenario(transport_server,
 
355
        transport_readonly_server, workingtree_format, preview_tree_pre)))
 
356
    scenarios.append(("PreviewTreePost", create_tree_scenario(transport_server,
 
357
        transport_readonly_server, workingtree_format, preview_tree_post)))
 
358
    return scenarios
 
359
 
 
360
 
 
361
def create_tree_scenario(transport_server, transport_readonly_server,
 
362
    workingtree_format, converter):
 
363
    """Create a scenario for the specified converter
 
364
 
 
365
    :param converter: A function that converts a workingtree into the
 
366
        desired format.
 
367
    :param workingtree_format: The particular workingtree format to
 
368
        convert from.
 
369
    :return: a (name, options) tuple, where options is a dict of values
 
370
        to be used as members of the TestCase.
 
371
    """
 
372
    scenario_options = wt_make_scenario(transport_server,
 
373
                                        transport_readonly_server,
 
374
                                        workingtree_format)
 
375
    scenario_options["_workingtree_to_test_tree"] = converter
 
376
    return scenario_options
 
377
 
 
378
 
 
379
def load_tests(standard_tests, module, loader):
 
380
    per_tree_mod_names = [
 
381
        'annotate_iter',
 
382
        'get_file_mtime',
 
383
        'get_file_with_stat',
 
384
        'get_root_id',
 
385
        'get_symlink_target',
 
386
        'inv',
 
387
        'iter_search_rules',
 
388
        'list_files',
 
389
        'path_content_summary',
 
390
        'revision_tree',
 
391
        'test_trees',
 
392
        'tree',
 
393
        'walkdirs',
395
394
        ]
396
 
 
397
 
    adapter = TreeTestProviderAdapter(
398
 
        default_transport,
 
395
    submod_tests = loader.loadTestsFromModuleNames(
 
396
        ['bzrlib.tests.per_tree.test_' + name
 
397
         for name in per_tree_mod_names])
 
398
    scenarios = make_scenarios(
 
399
        tests.default_transport,
399
400
        # None here will cause a readonly decorator to be created
400
401
        # by the TestCaseWithTransport.get_readonly_transport method.
401
402
        None,
402
403
        WorkingTreeFormat._formats.values() + _legacy_formats)
403
 
 
404
404
    # add the tests for the sub modules
405
 
    adapt_modules(test_tree_implementations, adapter, loader, result)
406
 
    return result
 
405
    return tests.multiply_tests(submod_tests, scenarios, standard_tests)