← Back to branch summary

~ubuntu-branches/ubuntu/precise/samba/precise

« back to all changes in this revision

Viewing changes to lib/testtools/testtools/tests/test_runtest.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/testtools/testtools/tests/test_runtest.py
 
1
# Copyright (c) 2009-2010 Jonathan M. Lange. See LICENSE for details.
 
2
 
 
3
"""Tests for the RunTest single test execution logic."""
 
4
 
 
5
from testtools import (
 
6
    ExtendedToOriginalDecorator,
 
7
    run_test_with,
 
8
    RunTest,
 
9
    TestCase,
 
10
    TestResult,
 
11
    )
 
12
from testtools.matchers import MatchesException, Is, Raises
 
13
from testtools.tests.helpers import ExtendedTestResult
 
14
 
 
15
 
 
16
class TestRunTest(TestCase):
 
17
 
 
18
    def make_case(self):
 
19
        class Case(TestCase):
 
20
            def test(self):
 
21
                pass
 
22
        return Case('test')
 
23
 
 
24
    def test___init___short(self):
 
25
        run = RunTest("bar")
 
26
        self.assertEqual("bar", run.case)
 
27
        self.assertEqual([], run.handlers)
 
28
 
 
29
    def test__init____handlers(self):
 
30
        handlers = [("quux", "baz")]
 
31
        run = RunTest("bar", handlers)
 
32
        self.assertEqual(handlers, run.handlers)
 
33
 
 
34
    def test_run_with_result(self):
 
35
        # test.run passes result down to _run_test_method.
 
36
        log = []
 
37
        class Case(TestCase):
 
38
            def _run_test_method(self, result):
 
39
                log.append(result)
 
40
        case = Case('_run_test_method')
 
41
        run = RunTest(case, lambda x: log.append(x))
 
42
        result = TestResult()
 
43
        run.run(result)
 
44
        self.assertEqual(1, len(log))
 
45
        self.assertEqual(result, log[0].decorated)
 
46
 
 
47
    def test_run_no_result_manages_new_result(self):
 
48
        log = []
 
49
        run = RunTest(self.make_case(), lambda x: log.append(x) or x)
 
50
        result = run.run()
 
51
        self.assertIsInstance(result.decorated, TestResult)
 
52
 
 
53
    def test__run_core_called(self):
 
54
        case = self.make_case()
 
55
        log = []
 
56
        run = RunTest(case, lambda x: x)
 
57
        run._run_core = lambda: log.append('foo')
 
58
        run.run()
 
59
        self.assertEqual(['foo'], log)
 
60
 
 
61
    def test__run_user_does_not_catch_keyboard(self):
 
62
        case = self.make_case()
 
63
        def raises():
 
64
            raise KeyboardInterrupt("yo")
 
65
        run = RunTest(case, None)
 
66
        run.result = ExtendedTestResult()
 
67
        self.assertThat(lambda: run._run_user(raises),
 
68
            Raises(MatchesException(KeyboardInterrupt)))
 
69
        self.assertEqual([], run.result._events)
 
70
 
 
71
    def test__run_user_calls_onException(self):
 
72
        case = self.make_case()
 
73
        log = []
 
74
        def handler(exc_info):
 
75
            log.append("got it")
 
76
            self.assertEqual(3, len(exc_info))
 
77
            self.assertIsInstance(exc_info[1], KeyError)
 
78
            self.assertIs(KeyError, exc_info[0])
 
79
        case.addOnException(handler)
 
80
        e = KeyError('Yo')
 
81
        def raises():
 
82
            raise e
 
83
        run = RunTest(case, [(KeyError, None)])
 
84
        run.result = ExtendedTestResult()
 
85
        status = run._run_user(raises)
 
86
        self.assertEqual(run.exception_caught, status)
 
87
        self.assertEqual([], run.result._events)
 
88
        self.assertEqual(["got it"], log)
 
89
 
 
90
    def test__run_user_can_catch_Exception(self):
 
91
        case = self.make_case()
 
92
        e = Exception('Yo')
 
93
        def raises():
 
94
            raise e
 
95
        log = []
 
96
        run = RunTest(case, [(Exception, None)])
 
97
        run.result = ExtendedTestResult()
 
98
        status = run._run_user(raises)
 
99
        self.assertEqual(run.exception_caught, status)
 
100
        self.assertEqual([], run.result._events)
 
101
        self.assertEqual([], log)
 
102
 
 
103
    def test__run_user_uncaught_Exception_raised(self):
 
104
        case = self.make_case()
 
105
        e = KeyError('Yo')
 
106
        def raises():
 
107
            raise e
 
108
        log = []
 
109
        def log_exc(self, result, err):
 
110
            log.append((result, err))
 
111
        run = RunTest(case, [(ValueError, log_exc)])
 
112
        run.result = ExtendedTestResult()
 
113
        self.assertThat(lambda: run._run_user(raises),
 
114
            Raises(MatchesException(KeyError)))
 
115
        self.assertEqual([], run.result._events)
 
116
        self.assertEqual([], log)
 
117
 
 
118
    def test__run_user_uncaught_Exception_from_exception_handler_raised(self):
 
119
        case = self.make_case()
 
120
        def broken_handler(exc_info):
 
121
            # ValueError because thats what we know how to catch - and must
 
122
            # not.
 
123
            raise ValueError('boo')
 
124
        case.addOnException(broken_handler)
 
125
        e = KeyError('Yo')
 
126
        def raises():
 
127
            raise e
 
128
        log = []
 
129
        def log_exc(self, result, err):
 
130
            log.append((result, err))
 
131
        run = RunTest(case, [(ValueError, log_exc)])
 
132
        run.result = ExtendedTestResult()
 
133
        self.assertThat(lambda: run._run_user(raises),
 
134
            Raises(MatchesException(ValueError)))
 
135
        self.assertEqual([], run.result._events)
 
136
        self.assertEqual([], log)
 
137
 
 
138
    def test__run_user_returns_result(self):
 
139
        case = self.make_case()
 
140
        def returns():
 
141
            return 1
 
142
        run = RunTest(case)
 
143
        run.result = ExtendedTestResult()
 
144
        self.assertEqual(1, run._run_user(returns))
 
145
        self.assertEqual([], run.result._events)
 
146
 
 
147
    def test__run_one_decorates_result(self):
 
148
        log = []
 
149
        class Run(RunTest):
 
150
            def _run_prepared_result(self, result):
 
151
                log.append(result)
 
152
                return result
 
153
        run = Run(self.make_case(), lambda x: x)
 
154
        result = run._run_one('foo')
 
155
        self.assertEqual([result], log)
 
156
        self.assertIsInstance(log[0], ExtendedToOriginalDecorator)
 
157
        self.assertEqual('foo', result.decorated)
 
158
 
 
159
    def test__run_prepared_result_calls_start_and_stop_test(self):
 
160
        result = ExtendedTestResult()
 
161
        case = self.make_case()
 
162
        run = RunTest(case, lambda x: x)
 
163
        run.run(result)
 
164
        self.assertEqual([
 
165
            ('startTest', case),
 
166
            ('addSuccess', case),
 
167
            ('stopTest', case),
 
168
            ], result._events)
 
169
 
 
170
    def test__run_prepared_result_calls_stop_test_always(self):
 
171
        result = ExtendedTestResult()
 
172
        case = self.make_case()
 
173
        def inner():
 
174
            raise Exception("foo")
 
175
        run = RunTest(case, lambda x: x)
 
176
        run._run_core = inner
 
177
        self.assertThat(lambda: run.run(result),
 
178
            Raises(MatchesException(Exception("foo"))))
 
179
        self.assertEqual([
 
180
            ('startTest', case),
 
181
            ('stopTest', case),
 
182
            ], result._events)
 
183
 
 
184
 
 
185
class CustomRunTest(RunTest):
 
186
 
 
187
    marker = object()
 
188
 
 
189
    def run(self, result=None):
 
190
        return self.marker
 
191
 
 
192
 
 
193
class TestTestCaseSupportForRunTest(TestCase):
 
194
 
 
195
    def test_pass_custom_run_test(self):
 
196
        class SomeCase(TestCase):
 
197
            def test_foo(self):
 
198
                pass
 
199
        result = TestResult()
 
200
        case = SomeCase('test_foo', runTest=CustomRunTest)
 
201
        from_run_test = case.run(result)
 
202
        self.assertThat(from_run_test, Is(CustomRunTest.marker))
 
203
 
 
204
    def test_default_is_runTest_class_variable(self):
 
205
        class SomeCase(TestCase):
 
206
            run_tests_with = CustomRunTest
 
207
            def test_foo(self):
 
208
                pass
 
209
        result = TestResult()
 
210
        case = SomeCase('test_foo')
 
211
        from_run_test = case.run(result)
 
212
        self.assertThat(from_run_test, Is(CustomRunTest.marker))
 
213
 
 
214
    def test_constructor_argument_overrides_class_variable(self):
 
215
        # If a 'runTest' argument is passed to the test's constructor, that
 
216
        # overrides the class variable.
 
217
        marker = object()
 
218
        class DifferentRunTest(RunTest):
 
219
            def run(self, result=None):
 
220
                return marker
 
221
        class SomeCase(TestCase):
 
222
            run_tests_with = CustomRunTest
 
223
            def test_foo(self):
 
224
                pass
 
225
        result = TestResult()
 
226
        case = SomeCase('test_foo', runTest=DifferentRunTest)
 
227
        from_run_test = case.run(result)
 
228
        self.assertThat(from_run_test, Is(marker))
 
229
 
 
230
    def test_decorator_for_run_test(self):
 
231
        # Individual test methods can be marked as needing a special runner.
 
232
        class SomeCase(TestCase):
 
233
            @run_test_with(CustomRunTest)
 
234
            def test_foo(self):
 
235
                pass
 
236
        result = TestResult()
 
237
        case = SomeCase('test_foo')
 
238
        from_run_test = case.run(result)
 
239
        self.assertThat(from_run_test, Is(CustomRunTest.marker))
 
240
 
 
241
    def test_extended_decorator_for_run_test(self):
 
242
        # Individual test methods can be marked as needing a special runner.
 
243
        # Extra arguments can be passed to the decorator which will then be
 
244
        # passed on to the RunTest object.
 
245
        marker = object()
 
246
        class FooRunTest(RunTest):
 
247
            def __init__(self, case, handlers=None, bar=None):
 
248
                super(FooRunTest, self).__init__(case, handlers)
 
249
                self.bar = bar
 
250
            def run(self, result=None):
 
251
                return self.bar
 
252
        class SomeCase(TestCase):
 
253
            @run_test_with(FooRunTest, bar=marker)
 
254
            def test_foo(self):
 
255
                pass
 
256
        result = TestResult()
 
257
        case = SomeCase('test_foo')
 
258
        from_run_test = case.run(result)
 
259
        self.assertThat(from_run_test, Is(marker))
 
260
 
 
261
    def test_works_as_inner_decorator(self):
 
262
        # Even if run_test_with is the innermost decorator, it will be
 
263
        # respected.
 
264
        def wrapped(function):
 
265
            """Silly, trivial decorator."""
 
266
            def decorated(*args, **kwargs):
 
267
                return function(*args, **kwargs)
 
268
            decorated.__name__ = function.__name__
 
269
            decorated.__dict__.update(function.__dict__)
 
270
            return decorated
 
271
        class SomeCase(TestCase):
 
272
            @wrapped
 
273
            @run_test_with(CustomRunTest)
 
274
            def test_foo(self):
 
275
                pass
 
276
        result = TestResult()
 
277
        case = SomeCase('test_foo')
 
278
        from_run_test = case.run(result)
 
279
        self.assertThat(from_run_test, Is(CustomRunTest.marker))
 
280
 
 
281
    def test_constructor_overrides_decorator(self):
 
282
        # If a 'runTest' argument is passed to the test's constructor, that
 
283
        # overrides the decorator.
 
284
        marker = object()
 
285
        class DifferentRunTest(RunTest):
 
286
            def run(self, result=None):
 
287
                return marker
 
288
        class SomeCase(TestCase):
 
289
            @run_test_with(CustomRunTest)
 
290
            def test_foo(self):
 
291
                pass
 
292
        result = TestResult()
 
293
        case = SomeCase('test_foo', runTest=DifferentRunTest)
 
294
        from_run_test = case.run(result)
 
295
        self.assertThat(from_run_test, Is(marker))
 
296
 
 
297
 
 
298
def test_suite():
 
299
    from unittest import TestLoader
 
300
    return TestLoader().loadTestsFromName(__name__)