← Back to branch summary

~ubuntu-branches/ubuntu/saucy/testresources/saucy-proposed

« back to all changes in this revision

Viewing changes to lib/testresources/tests/test_test_resource.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2013-06-05 08:26:03 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20130605082603-e8mgpeyzy8cz8m38
Tags: 0.2.7-0ubuntu1
New upstream release. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/testresources/tests/test_test_resource.py
15
15
#  license.
16
16
#
17
17
 
 
18
from fixtures.tests.helpers import LoggingFixture
18
19
import testtools
19
20
 
20
21
import testresources
35
36
    def __init__(self, name):
36
37
        self._name = name
37
38
 
 
39
    def __eq__(self, other):
 
40
        return self.__dict__ == other.__dict__
 
41
 
38
42
    def __cmp__(self, other):
39
43
        return cmp(self.__dict__, other.__dict__)
40
44
 
42
46
        return self._name
43
47
 
44
48
 
45
 
class MockResource(testresources.TestResource):
 
49
class MockResource(testresources.TestResourceManager):
46
50
    """Mock resource that logs the number of make and clean calls."""
47
51
 
48
52
    def __init__(self):
49
 
        testresources.TestResource.__init__(self)
 
53
        super(MockResource, self).__init__()
50
54
        self.makes = 0
51
55
        self.cleans = 0
52
56
 
62
66
    """Mock resource that logs the number of reset calls too."""
63
67
 
64
68
    def __init__(self):
65
 
        MockResource.__init__(self)
 
69
        super(MockResettableResource, self).__init__()
66
70
        self.resets = 0
67
71
 
68
 
    def reset(self, resource, result):
 
72
    def _reset(self, resource, dependency_resources):
69
73
        self.resets += 1
70
74
        resource._name += "!"
 
75
        self._dirty = False
71
76
        return resource
72
77
 
73
78
 
208
213
        self.assertEqual(1, resource_manager.resets)
209
214
        resource_manager.finishedWith(resource)
210
215
 
 
216
    def testIsResetIfDependenciesAreDirty(self):
 
217
        resource_manager = MockResource()
 
218
        dep1 = MockResettableResource()
 
219
        resource_manager.resources.append(("dep1", dep1))
 
220
        r = resource_manager.getResource()
 
221
        dep1.dirtied(r.dep1)
 
222
        # if we get the resource again, it should be cleaned.
 
223
        r = resource_manager.getResource()
 
224
        self.assertFalse(resource_manager.isDirty())
 
225
        self.assertFalse(dep1.isDirty())
 
226
        resource_manager.finishedWith(r)
 
227
        resource_manager.finishedWith(r)
 
228
 
211
229
    def testUsedResourceResetBetweenUses(self):
212
230
        resource_manager = MockResettableResource()
213
231
        # take two refs; like happens with OptimisingTestSuite.
279
297
        self.assertIs(resource, resource_manager._currentResource)
280
298
        resource_manager.finishedWith(resource)
281
299
 
282
 
    # The default implementation of reset() performs a make/clean if
283
 
    # the dirty flag is set.
284
300
    def testDirtiedSetsDirty(self):
285
301
        resource_manager = MockResource()
286
302
        resource = resource_manager.getResource()
319
335
        self.assertEqual(2, resource_manager.makes)
320
336
        self.assertEqual(1, resource_manager.cleans)
321
337
 
 
338
    def testDefaultResetResetsDependencies(self):
 
339
        resource_manager = MockResettableResource()
 
340
        dep1 = MockResettableResource()
 
341
        dep2 = MockResettableResource()
 
342
        resource_manager.resources.append(("dep1", dep1))
 
343
        resource_manager.resources.append(("dep2", dep2))
 
344
        # A typical OptimisingTestSuite workflow
 
345
        r_outer = resource_manager.getResource()
 
346
        # test 1
 
347
        r_inner = resource_manager.getResource()
 
348
        dep2.dirtied(r_inner.dep2)
 
349
        resource_manager.finishedWith(r_inner)
 
350
        # test 2
 
351
        r_inner = resource_manager.getResource()
 
352
        dep2.dirtied(r_inner.dep2)
 
353
        resource_manager.finishedWith(r_inner)
 
354
        resource_manager.finishedWith(r_outer)
 
355
        # Dep 1 was clean, doesn't do a reset, and should only have one
 
356
        # make+clean.
 
357
        self.assertEqual(1, dep1.makes)
 
358
        self.assertEqual(1, dep1.cleans)
 
359
        self.assertEqual(0, dep1.resets)
 
360
        # Dep 2 was dirty, so _reset happens, and likewise only one make and
 
361
        # clean.
 
362
        self.assertEqual(1, dep2.makes)
 
363
        self.assertEqual(1, dep2.cleans)
 
364
        self.assertEqual(1, dep2.resets)
 
365
        # The top layer should have had a reset happen, and only one make and
 
366
        # clean.
 
367
        self.assertEqual(1, resource_manager.makes)
 
368
        self.assertEqual(1, resource_manager.cleans)
 
369
        self.assertEqual(1, resource_manager.resets)
 
370
 
322
371
    def testDirtyingWhenUnused(self):
323
372
        resource_manager = MockResource()
324
373
        resource = resource_manager.getResource()
373
422
    def testResetActivityForResourceWithExtensions(self):
374
423
        result = ResultWithResourceExtensions()
375
424
        resource_manager = MockResource()
376
 
        expected = [("clean", "start", resource_manager),
377
 
            ("clean", "stop", resource_manager),
378
 
            ("make", "start", resource_manager),
379
 
            ("make", "stop", resource_manager)]
 
425
        expected = [("reset", "start", resource_manager),
 
426
            ("reset", "stop", resource_manager),
 
427
            ]
380
428
        resource_manager.getResource()
381
429
        r = resource_manager.getResource()
382
430
        resource_manager.dirtied(r)
446
494
        resource = mgr.getResource()
447
495
        self.assertTrue(mgr.isDirty())
448
496
        mgr.finishedWith(resource)
 
497
 
 
498
 
 
499
class TestFixtureResource(testtools.TestCase):
 
500
 
 
501
    def test_uses_setUp_cleanUp(self):
 
502
        fixture = LoggingFixture()
 
503
        mgr = testresources.FixtureResource(fixture)
 
504
        resource = mgr.getResource()
 
505
        self.assertEqual(fixture, resource)
 
506
        self.assertEqual(['setUp'], fixture.calls)
 
507
        mgr.finishedWith(resource)
 
508
        self.assertEqual(['setUp', 'cleanUp'], fixture.calls)
 
509
 
 
510
    def test_always_dirty(self):
 
511
        fixture = LoggingFixture()
 
512
        mgr = testresources.FixtureResource(fixture)
 
513
        resource = mgr.getResource()
 
514
        self.assertTrue(mgr.isDirty())
 
515
        mgr.finishedWith(resource)
 
516
 
 
517
    def test_reset_called(self):
 
518
        fixture = LoggingFixture()
 
519
        mgr = testresources.FixtureResource(fixture)
 
520
        resource = mgr.getResource()
 
521
        mgr.reset(resource)
 
522
        mgr.finishedWith(resource)
 
523
        self.assertEqual(
 
524
            ['setUp', 'reset', 'cleanUp'], fixture.calls)