← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: v.ladeuil+lp at free
  • Date: 2007-05-18 18:20:31 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070518182031-gbg2cgidv5l20x9p
Takes Robert comments into account.

* bzrlib/transport/ftp.py:
(FtpTransport.__init__): Write a better explanation.

* bzrlib/tests/test_init.py:
(InstrumentedTransport): Just make hooks a class attribute.
(InstrumentedTransport._get_FTP): Run hook directly in the for
loop.
(TransportHooks.run_hook, TransportHooks.uninstall_hook): Not
needed. The hooks should be cleaned up by the test itself.
(TestInit.setUp.cleanup): Resset to default hooks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
50
50
                          TestUtil,
51
51
                          TextTestRunner,
52
52
                          UnavailableFeature,
 
53
                          clean_selftest_output,
53
54
                          iter_suite_tests,
54
55
                          filter_suite_by_re,
55
56
                          sort_suite_by_re,
56
 
                          test_lsprof,
57
 
                          test_suite,
 
57
                          test_suite
58
58
                          )
59
59
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
60
60
from bzrlib.tests.TestUtil import _load_module_by_name
113
113
            def get_test_permutations(self):
114
114
                return sample_permutation
115
115
        sample_permutation = [(1,2), (3,4)]
116
 
        from bzrlib.tests.test_transport_implementations \
117
 
            import TransportTestProviderAdapter
 
116
        from bzrlib.transport import TransportTestProviderAdapter
118
117
        adapter = TransportTestProviderAdapter()
119
118
        self.assertEqual(sample_permutation,
120
119
                         adapter.get_transport_test_permutations(MockModule()))
125
124
        # - we assume if this matches its probably doing the right thing
126
125
        # especially in combination with the tests for setting the right
127
126
        # classes below.
128
 
        from bzrlib.tests.test_transport_implementations \
129
 
            import TransportTestProviderAdapter
130
 
        from bzrlib.transport import _get_transport_modules
 
127
        from bzrlib.transport import (TransportTestProviderAdapter,
 
128
                                      _get_transport_modules
 
129
                                      )
131
130
        modules = _get_transport_modules()
132
131
        permutation_count = 0
133
132
        for module in modules:
150
149
        # This test used to know about all the possible transports and the
151
150
        # order they were returned but that seems overly brittle (mbp
152
151
        # 20060307)
153
 
        from bzrlib.tests.test_transport_implementations \
154
 
            import TransportTestProviderAdapter
155
 
        scenarios = TransportTestProviderAdapter().scenarios
 
152
        input_test = TestTransportProviderAdapter(
 
153
            "test_adapter_sets_transport_class")
 
154
        from bzrlib.transport import TransportTestProviderAdapter
 
155
        suite = TransportTestProviderAdapter().adapt(input_test)
 
156
        tests = list(iter(suite))
 
157
        self.assertTrue(len(tests) > 6)
156
158
        # there are at least that many builtin transports
157
 
        self.assertTrue(len(scenarios) > 6)
158
 
        one_scenario = scenarios[0]
159
 
        self.assertIsInstance(one_scenario[0], str)
160
 
        self.assertTrue(issubclass(one_scenario[1]["transport_class"],
 
159
        one_test = tests[0]
 
160
        self.assertTrue(issubclass(one_test.transport_class, 
161
161
                                   bzrlib.transport.Transport))
162
 
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
 
162
        self.assertTrue(issubclass(one_test.transport_server, 
163
163
                                   bzrlib.transport.Server))
164
164
 
165
165
 
166
166
class TestBranchProviderAdapter(TestCase):
167
167
    """A group of tests that test the branch implementation test adapter."""
168
168
 
169
 
    def test_constructor(self):
 
169
    def test_adapted_tests(self):
170
170
        # check that constructor parameters are passed through to the adapted
171
171
        # test.
172
 
        from bzrlib.tests.branch_implementations import BranchTestProviderAdapter
 
172
        from bzrlib.branch import BranchTestProviderAdapter
 
173
        input_test = TestBranchProviderAdapter(
 
174
            "test_adapted_tests")
173
175
        server1 = "a"
174
176
        server2 = "b"
175
177
        formats = [("c", "C"), ("d", "D")]
176
178
        adapter = BranchTestProviderAdapter(server1, server2, formats)
177
 
        self.assertEqual(2, len(adapter.scenarios))
178
 
        self.assertEqual([
179
 
            ('str',
180
 
             {'branch_format': 'c',
181
 
              'bzrdir_format': 'C',
182
 
              'transport_readonly_server': 'b',
183
 
              'transport_server': 'a'}),
184
 
            ('str',
185
 
             {'branch_format': 'd',
186
 
              'bzrdir_format': 'D',
187
 
              'transport_readonly_server': 'b',
188
 
              'transport_server': 'a'})],
189
 
            adapter.scenarios)
 
179
        suite = adapter.adapt(input_test)
 
180
        tests = list(iter(suite))
 
181
        self.assertEqual(2, len(tests))
 
182
        self.assertEqual(tests[0].branch_format, formats[0][0])
 
183
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
184
        self.assertEqual(tests[0].transport_server, server1)
 
185
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
186
        self.assertEqual(tests[1].branch_format, formats[1][0])
 
187
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
188
        self.assertEqual(tests[1].transport_server, server1)
 
189
        self.assertEqual(tests[1].transport_readonly_server, server2)
190
190
 
191
191
 
192
192
class TestBzrDirProviderAdapter(TestCase):
195
195
    def test_adapted_tests(self):
196
196
        # check that constructor parameters are passed through to the adapted
197
197
        # test.
198
 
        from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
 
198
        from bzrlib.bzrdir import BzrDirTestProviderAdapter
 
199
        input_test = TestBzrDirProviderAdapter(
 
200
            "test_adapted_tests")
199
201
        vfs_factory = "v"
200
202
        server1 = "a"
201
203
        server2 = "b"
202
204
        formats = ["c", "d"]
203
205
        adapter = BzrDirTestProviderAdapter(vfs_factory,
204
206
            server1, server2, formats)
205
 
        self.assertEqual([
206
 
            ('str',
207
 
             {'bzrdir_format': 'c',
208
 
              'transport_readonly_server': 'b',
209
 
              'transport_server': 'a',
210
 
              'vfs_transport_factory': 'v'}),
211
 
            ('str',
212
 
             {'bzrdir_format': 'd',
213
 
              'transport_readonly_server': 'b',
214
 
              'transport_server': 'a',
215
 
              'vfs_transport_factory': 'v'})],
216
 
            adapter.scenarios)
 
207
        suite = adapter.adapt(input_test)
 
208
        tests = list(iter(suite))
 
209
        self.assertEqual(2, len(tests))
 
210
        self.assertEqual(tests[0].bzrdir_format, formats[0])
 
211
        self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
 
212
        self.assertEqual(tests[0].transport_server, server1)
 
213
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
214
        self.assertEqual(tests[1].bzrdir_format, formats[1])
 
215
        self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
 
216
        self.assertEqual(tests[1].transport_server, server1)
 
217
        self.assertEqual(tests[1].transport_readonly_server, server2)
217
218
 
218
219
 
219
220
class TestRepositoryProviderAdapter(TestCase):
220
221
    """A group of tests that test the repository implementation test adapter."""
221
222
 
222
 
    def test_constructor(self):
223
 
        # check that constructor parameters are passed through to the
224
 
        # scenarios.
225
 
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
223
    def test_adapted_tests(self):
 
224
        # check that constructor parameters are passed through to the adapted
 
225
        # test.
 
226
        from bzrlib.repository import RepositoryTestProviderAdapter
 
227
        input_test = TestRepositoryProviderAdapter(
 
228
            "test_adapted_tests")
226
229
        server1 = "a"
227
230
        server2 = "b"
228
231
        formats = [("c", "C"), ("d", "D")]
229
232
        adapter = RepositoryTestProviderAdapter(server1, server2, formats)
230
 
        self.assertEqual([
231
 
            ('str',
232
 
             {'bzrdir_format': 'C',
233
 
              'repository_format': 'c',
234
 
              'transport_readonly_server': 'b',
235
 
              'transport_server': 'a'}),
236
 
            ('str',
237
 
             {'bzrdir_format': 'D',
238
 
              'repository_format': 'd',
239
 
              'transport_readonly_server': 'b',
240
 
              'transport_server': 'a'})],
241
 
            adapter.scenarios)
 
233
        suite = adapter.adapt(input_test)
 
234
        tests = list(iter(suite))
 
235
        self.assertEqual(2, len(tests))
 
236
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
237
        self.assertEqual(tests[0].repository_format, formats[0][0])
 
238
        self.assertEqual(tests[0].transport_server, server1)
 
239
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
240
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
241
        self.assertEqual(tests[1].repository_format, formats[1][0])
 
242
        self.assertEqual(tests[1].transport_server, server1)
 
243
        self.assertEqual(tests[1].transport_readonly_server, server2)
242
244
 
243
245
    def test_setting_vfs_transport(self):
244
246
        """The vfs_transport_factory can be set optionally."""
245
 
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
246
 
        formats = [("a", "b"), ("c", "d")]
 
247
        from bzrlib.repository import RepositoryTestProviderAdapter
 
248
        input_test = TestRepositoryProviderAdapter(
 
249
            "test_adapted_tests")
 
250
        formats = [("c", "C")]
247
251
        adapter = RepositoryTestProviderAdapter(None, None, formats,
248
252
            vfs_transport_factory="vfs")
249
 
        self.assertEqual([
250
 
            ('str',
251
 
             {'bzrdir_format': 'b',
252
 
              'repository_format': 'a',
253
 
              'transport_readonly_server': None,
254
 
              'transport_server': None,
255
 
              'vfs_transport_factory': 'vfs'}),
256
 
            ('str',
257
 
             {'bzrdir_format': 'd',
258
 
              'repository_format': 'c',
259
 
              'transport_readonly_server': None,
260
 
              'transport_server': None,
261
 
              'vfs_transport_factory': 'vfs'})],
262
 
            adapter.scenarios)
263
 
 
264
 
    def test_formats_to_scenarios(self):
265
 
        """The adapter can generate all the scenarios needed."""
266
 
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
267
 
        no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
268
 
            [], None)
269
 
        vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
270
 
            [], vfs_transport_factory="vfs")
271
 
        # no_vfs generate scenarios without vfs_transport_factor
272
 
        formats = [("c", "C"), (1, "D")]
273
 
        self.assertEqual([
274
 
            ('str',
275
 
             {'bzrdir_format': 'C',
276
 
              'repository_format': 'c',
277
 
              'transport_readonly_server': 'readonly',
278
 
              'transport_server': 'server'}),
279
 
            ('int',
280
 
             {'bzrdir_format': 'D',
281
 
              'repository_format': 1,
282
 
              'transport_readonly_server': 'readonly',
283
 
              'transport_server': 'server'})],
284
 
            no_vfs_adapter.formats_to_scenarios(formats))
285
 
        self.assertEqual([
286
 
            ('str',
287
 
             {'bzrdir_format': 'C',
288
 
              'repository_format': 'c',
289
 
              'transport_readonly_server': 'readonly',
290
 
              'transport_server': 'server',
291
 
              'vfs_transport_factory': 'vfs'}),
292
 
            ('int',
293
 
             {'bzrdir_format': 'D',
294
 
              'repository_format': 1,
295
 
              'transport_readonly_server': 'readonly',
296
 
              'transport_server': 'server',
297
 
              'vfs_transport_factory': 'vfs'})],
298
 
            vfs_adapter.formats_to_scenarios(formats))
299
 
 
300
 
 
301
 
class TestTestScenarioApplier(TestCase):
302
 
    """Tests for the test adaption facilities."""
303
 
 
304
 
    def test_adapt_applies_scenarios(self):
305
 
        from bzrlib.tests.repository_implementations import TestScenarioApplier
306
 
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
307
 
        adapter = TestScenarioApplier()
308
 
        adapter.scenarios = [("1", "dict"), ("2", "settings")]
309
 
        calls = []
310
 
        def capture_call(test, scenario):
311
 
            calls.append((test, scenario))
312
 
            return test
313
 
        adapter.adapt_test_to_scenario = capture_call
314
 
        adapter.adapt(input_test)
315
 
        self.assertEqual([(input_test, ("1", "dict")),
316
 
            (input_test, ("2", "settings"))], calls)
317
 
 
318
 
    def test_adapt_test_to_scenario(self):
319
 
        from bzrlib.tests.repository_implementations import TestScenarioApplier
320
 
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
321
 
        adapter = TestScenarioApplier()
322
 
        # setup two adapted tests
323
 
        adapted_test1 = adapter.adapt_test_to_scenario(input_test,
324
 
            ("new id",
325
 
            {"bzrdir_format":"bzr_format",
326
 
             "repository_format":"repo_fmt",
327
 
             "transport_server":"transport_server",
328
 
             "transport_readonly_server":"readonly-server"}))
329
 
        adapted_test2 = adapter.adapt_test_to_scenario(input_test,
330
 
            ("new id 2", {"bzrdir_format":None}))
331
 
        # input_test should have been altered.
332
 
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
333
 
        # the new tests are mutually incompatible, ensuring it has 
334
 
        # made new ones, and unspecified elements in the scenario
335
 
        # should not have been altered.
336
 
        self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
337
 
        self.assertEqual("repo_fmt", adapted_test1.repository_format)
338
 
        self.assertEqual("transport_server", adapted_test1.transport_server)
339
 
        self.assertEqual("readonly-server",
340
 
            adapted_test1.transport_readonly_server)
341
 
        self.assertEqual(
342
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
343
 
            "test_adapt_test_to_scenario(new id)",
344
 
            adapted_test1.id())
345
 
        self.assertEqual(None, adapted_test2.bzrdir_format)
346
 
        self.assertEqual(
347
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
348
 
            "test_adapt_test_to_scenario(new id 2)",
349
 
            adapted_test2.id())
 
253
        suite = adapter.adapt(input_test)
 
254
        tests = list(iter(suite))
 
255
        self.assertEqual(1, len(tests))
 
256
        self.assertEqual(tests[0].vfs_transport_factory, "vfs")
350
257
 
351
258
 
352
259
class TestInterRepositoryProviderAdapter(TestCase):
355
262
    def test_adapted_tests(self):
356
263
        # check that constructor parameters are passed through to the adapted
357
264
        # test.
358
 
        from bzrlib.tests.interrepository_implementations import \
359
 
            InterRepositoryTestProviderAdapter
 
265
        from bzrlib.repository import InterRepositoryTestProviderAdapter
 
266
        input_test = TestInterRepositoryProviderAdapter(
 
267
            "test_adapted_tests")
360
268
        server1 = "a"
361
269
        server2 = "b"
362
270
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
363
271
        adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
364
 
        self.assertEqual([
365
 
            ('str',
366
 
             {'interrepo_class': str,
367
 
              'repository_format': 'C1',
368
 
              'repository_format_to': 'C2',
369
 
              'transport_readonly_server': 'b',
370
 
              'transport_server': 'a'}),
371
 
            ('int',
372
 
             {'interrepo_class': int,
373
 
              'repository_format': 'D1',
374
 
              'repository_format_to': 'D2',
375
 
              'transport_readonly_server': 'b',
376
 
              'transport_server': 'a'})],
377
 
            adapter.formats_to_scenarios(formats))
 
272
        suite = adapter.adapt(input_test)
 
273
        tests = list(iter(suite))
 
274
        self.assertEqual(2, len(tests))
 
275
        self.assertEqual(tests[0].interrepo_class, formats[0][0])
 
276
        self.assertEqual(tests[0].repository_format, formats[0][1])
 
277
        self.assertEqual(tests[0].repository_format_to, formats[0][2])
 
278
        self.assertEqual(tests[0].transport_server, server1)
 
279
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
280
        self.assertEqual(tests[1].interrepo_class, formats[1][0])
 
281
        self.assertEqual(tests[1].repository_format, formats[1][1])
 
282
        self.assertEqual(tests[1].repository_format_to, formats[1][2])
 
283
        self.assertEqual(tests[1].transport_server, server1)
 
284
        self.assertEqual(tests[1].transport_readonly_server, server2)
378
285
 
379
286
 
380
287
class TestInterVersionedFileProviderAdapter(TestCase):
381
288
    """A group of tests that test the InterVersionedFile test adapter."""
382
289
 
383
 
    def test_scenarios(self):
 
290
    def test_adapted_tests(self):
384
291
        # check that constructor parameters are passed through to the adapted
385
292
        # test.
386
 
        from bzrlib.tests.interversionedfile_implementations \
387
 
            import InterVersionedFileTestProviderAdapter
 
293
        from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
 
294
        input_test = TestInterRepositoryProviderAdapter(
 
295
            "test_adapted_tests")
388
296
        server1 = "a"
389
297
        server2 = "b"
390
298
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
391
299
        adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
392
 
        self.assertEqual([
393
 
            ('str',
394
 
             {'interversionedfile_class':str,
395
 
              'transport_readonly_server': 'b',
396
 
              'transport_server': 'a',
397
 
              'versionedfile_factory': 'C1',
398
 
              'versionedfile_factory_to': 'C2'}),
399
 
            ('int',
400
 
             {'interversionedfile_class': int,
401
 
              'transport_readonly_server': 'b',
402
 
              'transport_server': 'a',
403
 
              'versionedfile_factory': 'D1',
404
 
              'versionedfile_factory_to': 'D2'})],
405
 
            adapter.scenarios)
 
300
        suite = adapter.adapt(input_test)
 
301
        tests = list(iter(suite))
 
302
        self.assertEqual(2, len(tests))
 
303
        self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
 
304
        self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
 
305
        self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
 
306
        self.assertEqual(tests[0].transport_server, server1)
 
307
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
308
        self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
 
309
        self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
 
310
        self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
 
311
        self.assertEqual(tests[1].transport_server, server1)
 
312
        self.assertEqual(tests[1].transport_readonly_server, server2)
406
313
 
407
314
 
408
315
class TestRevisionStoreProviderAdapter(TestCase):
409
316
    """A group of tests that test the RevisionStore test adapter."""
410
317
 
411
 
    def test_scenarios(self):
 
318
    def test_adapted_tests(self):
412
319
        # check that constructor parameters are passed through to the adapted
413
320
        # test.
414
 
        from bzrlib.tests.revisionstore_implementations \
415
 
            import RevisionStoreTestProviderAdapter
 
321
        from bzrlib.store.revision import RevisionStoreTestProviderAdapter
 
322
        input_test = TestRevisionStoreProviderAdapter(
 
323
            "test_adapted_tests")
416
324
        # revision stores need a store factory - i.e. RevisionKnit
417
325
        #, a readonly and rw transport 
418
326
        # transport servers:
420
328
        server2 = "b"
421
329
        store_factories = ["c", "d"]
422
330
        adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
423
 
        self.assertEqual([
424
 
            ('c',
425
 
             {'store_factory': 'c',
426
 
              'transport_readonly_server': 'b',
427
 
              'transport_server': 'a'}),
428
 
            ('d',
429
 
             {'store_factory': 'd',
430
 
              'transport_readonly_server': 'b',
431
 
              'transport_server': 'a'})],
432
 
            adapter.scenarios)
 
331
        suite = adapter.adapt(input_test)
 
332
        tests = list(iter(suite))
 
333
        self.assertEqual(2, len(tests))
 
334
        self.assertEqual(tests[0].store_factory, store_factories[0][0])
 
335
        self.assertEqual(tests[0].transport_server, server1)
 
336
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
337
        self.assertEqual(tests[1].store_factory, store_factories[1][0])
 
338
        self.assertEqual(tests[1].transport_server, server1)
 
339
        self.assertEqual(tests[1].transport_readonly_server, server2)
433
340
 
434
341
 
435
342
class TestWorkingTreeProviderAdapter(TestCase):
436
343
    """A group of tests that test the workingtree implementation test adapter."""
437
344
 
438
 
    def test_scenarios(self):
 
345
    def test_adapted_tests(self):
439
346
        # check that constructor parameters are passed through to the adapted
440
347
        # test.
441
 
        from bzrlib.tests.workingtree_implementations \
442
 
            import WorkingTreeTestProviderAdapter
 
348
        from bzrlib.workingtree import WorkingTreeTestProviderAdapter
 
349
        input_test = TestWorkingTreeProviderAdapter(
 
350
            "test_adapted_tests")
443
351
        server1 = "a"
444
352
        server2 = "b"
445
353
        formats = [("c", "C"), ("d", "D")]
446
354
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
447
 
        self.assertEqual([
448
 
            ('str',
449
 
             {'bzrdir_format': 'C',
450
 
              'transport_readonly_server': 'b',
451
 
              'transport_server': 'a',
452
 
              'workingtree_format': 'c'}),
453
 
            ('str',
454
 
             {'bzrdir_format': 'D',
455
 
              'transport_readonly_server': 'b',
456
 
              'transport_server': 'a',
457
 
              'workingtree_format': 'd'})],
458
 
            adapter.scenarios)
 
355
        suite = adapter.adapt(input_test)
 
356
        tests = list(iter(suite))
 
357
        self.assertEqual(2, len(tests))
 
358
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
 
359
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
360
        self.assertEqual(tests[0].transport_server, server1)
 
361
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
362
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
 
363
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
364
        self.assertEqual(tests[1].transport_server, server1)
 
365
        self.assertEqual(tests[1].transport_readonly_server, server2)
459
366
 
460
367
 
461
368
class TestTreeProviderAdapter(TestCase):
713
620
        result.extractBenchmarkTime(self)
714
621
        timed_string = result._testTimeString()
715
622
        # without explicit benchmarking, we should get a simple time.
716
 
        self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
 
623
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
717
624
        # if a benchmark time is given, we want a x of y style result.
718
625
        self.time(time.sleep, 0.001)
719
626
        result.extractBenchmarkTime(self)
720
627
        timed_string = result._testTimeString()
721
 
        self.assertContainsRe(
722
 
            timed_string, "^ +[0-9]+ms/ +[0-9]+ms$")
 
628
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms/ *[ 1-9][0-9]ms$")
723
629
        # extracting the time from a non-bzrlib testcase sets to None
724
630
        result._recordTestStartTime()
725
631
        result.extractBenchmarkTime(
726
632
            unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
727
633
        timed_string = result._testTimeString()
728
 
        self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
 
634
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
729
635
        # cheat. Yes, wash thy mouth out with soap.
730
636
        self._benchtime = None
731
637
 
773
679
 
774
680
    def test_lsprofiling(self):
775
681
        """Verbose test result prints lsprof statistics from test cases."""
776
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
682
        try:
 
683
            import bzrlib.lsprof
 
684
        except ImportError:
 
685
            raise TestSkipped("lsprof not installed.")
777
686
        result_stream = StringIO()
778
687
        result = bzrlib.tests.VerboseTestResult(
779
688
            unittest._WritelnDecorator(result_stream),
1062
971
        def skipping_test():
1063
972
            raise TestSkipped('test intentionally skipped')
1064
973
 
1065
 
        runner = TextTestRunner(stream=self._log_file)
 
974
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
1066
975
        test = unittest.FunctionTestCase(skipping_test)
1067
976
        result = self.run_test_runner(runner, test)
1068
977
        self.assertTrue(result.wasSuccessful())
1081
990
            def cleanup(self):
1082
991
                self.counter -= 1
1083
992
 
1084
 
        runner = TextTestRunner(stream=self._log_file)
 
993
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
1085
994
        test = SkippedSetupTest('test_skip')
1086
995
        result = self.run_test_runner(runner, test)
1087
996
        self.assertTrue(result.wasSuccessful())
1101
1010
            def cleanup(self):
1102
1011
                self.counter -= 1
1103
1012
 
1104
 
        runner = TextTestRunner(stream=self._log_file)
 
1013
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
1105
1014
        test = SkippedTest('test_skip')
1106
1015
        result = self.run_test_runner(runner, test)
1107
1016
        self.assertTrue(result.wasSuccessful())
1220
1129
class TestTestCase(TestCase):
1221
1130
    """Tests that test the core bzrlib TestCase."""
1222
1131
 
1223
 
    def test_debug_flags_sanitised(self):
1224
 
        """The bzrlib debug flags should be sanitised by setUp."""
1225
 
        # we could set something and run a test that will check
1226
 
        # it gets santised, but this is probably sufficient for now:
1227
 
        # if someone runs the test with -Dsomething it will error.
1228
 
        self.assertEqual(set(), bzrlib.debug.debug_flags)
1229
 
 
1230
1132
    def inner_test(self):
1231
1133
        # the inner child test
1232
1134
        note("inner_test")
1292
1194
        
1293
1195
        Each self.time() call is individually and separately profiled.
1294
1196
        """
1295
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
1197
        try:
 
1198
            import bzrlib.lsprof
 
1199
        except ImportError:
 
1200
            raise TestSkipped("lsprof not installed.")
1296
1201
        # overrides the class member with an instance member so no cleanup 
1297
1202
        # needed.
1298
1203
        self._gather_lsprof_in_benchmarks = True
1511
1416
        self.assertEqual([True], factory_called)
1512
1417
 
1513
1418
 
 
1419
class TestSelftestCleanOutput(TestCaseInTempDir):
 
1420
 
 
1421
    def test_clean_output(self):
 
1422
        # test functionality of clean_selftest_output()
 
1423
        self.build_tree(['test0000.tmp/', 'test0001.tmp/',
 
1424
                         'bzrlib/', 'tests/',
 
1425
                         'bzr', 'setup.py', 'test9999.tmp'])
 
1426
 
 
1427
        root = os.getcwdu()
 
1428
        before = os.listdir(root)
 
1429
        before.sort()
 
1430
        self.assertEquals(['bzr','bzrlib','setup.py',
 
1431
                           'test0000.tmp','test0001.tmp',
 
1432
                           'test9999.tmp','tests'],
 
1433
                           before)
 
1434
        clean_selftest_output(root, quiet=True)
 
1435
        after = os.listdir(root)
 
1436
        after.sort()
 
1437
        self.assertEquals(['bzr','bzrlib','setup.py',
 
1438
                           'test9999.tmp','tests'],
 
1439
                           after)
 
1440
 
 
1441
    def test_clean_readonly(self):
 
1442
        # test for delete read-only files
 
1443
        self.build_tree(['test0000.tmp/', 'test0000.tmp/foo'])
 
1444
        osutils.make_readonly('test0000.tmp/foo')
 
1445
        root = os.getcwdu()
 
1446
        before = os.listdir(root);  before.sort()
 
1447
        self.assertEquals(['test0000.tmp'], before)
 
1448
        clean_selftest_output(root, quiet=True)
 
1449
        after = os.listdir(root);   after.sort()
 
1450
        self.assertEquals([], after)
 
1451
 
 
1452
 
1514
1453
class TestKnownFailure(TestCase):
1515
1454
 
1516
1455
    def test_known_failure(self):
1596
1535
            'TestSelftestFiltering.test_filter_suite_by_re')
1597
1536
        self.assertEquals(sorted(self.all_names), sorted(sorted_names))
1598
1537
 
1599
 
 
1600
 
class TestCheckInventoryShape(TestCaseWithTransport):
1601
 
 
1602
 
    def test_check_inventory_shape(self):
1603
 
        files = ['a', 'b/', 'b/c']
1604
 
        tree = self.make_branch_and_tree('.')
1605
 
        self.build_tree(files)
1606
 
        tree.add(files)
1607
 
        tree.lock_read()
1608
 
        try:
1609
 
            self.check_inventory_shape(tree.inventory, files)
1610
 
        finally:
1611
 
            tree.unlock()