← Back to branch summary

~testdoc-dev/testdoc/trunk.git

« back to all changes in this revision

Viewing changes to testdoc/tests/test_testdoc.py

  • Committer: jml@canonical.com
  • Date: 2007-03-31 02:50:14 UTC
  • Revision ID: git-v1:bb5f9a22a05de178020fc41b770a31bafe89cd44
Use underscores for naming methods, split out natural language stuff, move
title_case to module level,  make tests less brittle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
testdoc/tests/test_testdoc.py
1
1
import inspect
2
2
import unittest
3
3
 
4
 
from testdoc import split_name, find_tests, Documenter
 
4
from testdoc import split_name, find_tests, Documenter, title_case
5
5
 
6
6
 
7
7
class TestSplitName(unittest.TestCase):
8
8
 
9
 
    def test_singleWord(self):
 
9
    def test_single_word(self):
10
10
        self.assertEqual(split_name('single'), ['single'])
11
11
 
12
12
    def test_underscores(self):
13
13
        self.assertEqual(split_name('split_name'), ['split', 'name'])
14
14
 
15
 
    def test_camelCase(self):
 
15
    def test_camel_case(self):
16
16
        self.assertEqual(split_name('splitName'), ['split', 'name'])
17
17
        self.assertEqual(
18
18
            split_name('splitLongName'), ['split', 'long', 'name'])
19
19
        self.assertEqual(split_name('splitAName'), ['split', 'a', 'name'])
20
20
 
21
 
    def test_camelCaseWithCaps(self):
 
21
    def test_camel_case_with_caps(self):
22
22
        self.assertEqual(split_name('splitDNSName'), ['split', 'DNS', 'name'])
23
23
 
24
 
    def test_singleUnderscore(self):
 
24
    def test_single_underscore(self):
25
25
        """Single underscores are used for reflection prefixes, so we'd like to
26
26
        ignore them.
27
27
        """
28
28
        self.assertEqual(
29
29
            split_name('test_splitName'), ['test', 'split', 'name'])
30
30
 
31
 
    def test_multipleUnderscores(self):
 
31
    def test_multiple_underscores(self):
32
32
        """If there are multiple underscores, but camel case, then someone is
33
33
        probably referring to a camel-cased identifier in their name.
34
34
        """
44
44
    def __init__(self):
45
45
        self.log = []
46
46
 
47
 
    def gotModule(self, module):
 
47
    def got_module(self, module):
48
48
        self.log.append(('module', module))
49
49
 
50
 
    def gotTestClass(self, klass):
 
50
    def got_test_class(self, klass):
51
51
        self.log.append(('class', klass))
52
52
 
53
 
    def gotTest(self, method):
 
53
    def got_test(self, method):
54
54
        self.log.append(('method', method))
55
55
 
56
56
 
109
109
 
110
110
    def test_module(self):
111
111
        from testdoc.tests import empty
112
 
        self.documenter.gotModule(empty)
113
 
        self.assertEqual(
114
 
            self.formatter.log, [
115
 
                ('title', 'testdoc.tests.empty')])
116
 
 
117
 
    def test_emptyModuleWithDocstrings(self):
118
 
        from testdoc.tests import hastests
119
 
        self.documenter.gotModule(hastests)
120
 
        self.assertEqual(
121
 
            self.formatter.log, [
122
 
                ('title', 'testdoc.tests.hastests'),
123
 
                ('para', self.documenter.getDocs(hastests))])
124
 
 
125
 
    def test_emptyCase(self):
126
 
        from testdoc.tests import hastests
127
 
        self.documenter.gotTestClass(hastests.SomeTest)
128
 
        self.assertEqual(
129
 
            self.formatter.log, [
130
 
                ('section', self.documenter.titleCase(['Some'])),
131
 
                ('para', self.documenter.getDocs(hastests.SomeTest))])
 
112
        self.documenter.got_module(empty)
 
113
        self.assertEqual(
 
114
            self.formatter.log,
 
115
            [('title', self.documenter.format_module('testdoc.tests.empty'))])
 
116
 
 
117
    def test_empty_module_with_docstrings(self):
 
118
        from testdoc.tests import hastests
 
119
        self.documenter.got_module(hastests)
 
120
        self.assertEqual(
 
121
            self.formatter.log,
 
122
            [('title',
 
123
              self.documenter.format_module('testdoc.tests.hastests')),
 
124
             ('para', self.documenter.extract_docs(hastests))])
 
125
 
 
126
    def test_empty_case(self):
 
127
        from testdoc.tests import hastests
 
128
        self.documenter.got_test_class(hastests.SomeTest)
 
129
        self.assertEqual(
 
130
            self.formatter.log,
 
131
            [('section', self.documenter.format_test_class('SomeTest')),
 
132
             ('para', self.documenter.extract_docs(hastests.SomeTest))])
132
133
 
133
134
    def test_method(self):
134
135
        from testdoc.tests import hastests
135
 
        self.documenter.gotTest(hastests.SomeTest.test_foo_handles_qux)
136
 
        self.assertEqual(
137
 
            self.formatter.log, [
138
 
                ('subsection',
139
 
                 self.documenter.titleCase(['Foo', 'handles', 'qux'])),
140
 
                ('para', self.documenter.getDocs(
141
 
                    hastests.SomeTest.test_foo_handles_qux))])
142
 
 
143
 
    def test_titleCase(self):
144
 
        self.assertEqual(
145
 
            self.documenter.titleCase(['foo', 'BAR', 'a', 'In', 'Baz', '999']),
146
 
            'Foo BAR a in Baz 999')
147
 
        self.assertEqual(
148
 
            self.documenter.titleCase(['in', 'a', 'bind']),
149
 
            'In a Bind')
150
 
 
151
 
    # Docstrings first, then comments, then nothing
 
136
        self.documenter.got_test(hastests.SomeTest.test_foo_handles_qux)
 
137
        self.assertEqual(
 
138
            self.formatter.log,
 
139
            [('subsection',
 
140
              self.documenter.format_test('test_foo_handles_qux')),
 
141
             ('para', self.documenter.extract_docs(
 
142
            hastests.SomeTest.test_foo_handles_qux))])
 
143
 
 
144
    def test_title_case(self):
 
145
        self.assertEqual(
 
146
            title_case(['foo', 'BAR', 'a', 'In', 'Baz', '999', 'has']),
 
147
            'Foo BAR a in Baz 999 has')
 
148
        self.assertEqual(title_case(['in', 'a', 'bind']), 'In a Bind')
 
149
 
 
150
    def test_format_module(self):
 
151
        """The natural language display of a module name is just the name of
 
152
        the module.
 
153
        """
 
154
        self.assertEqual('foo.bar.baz',
 
155
                         self.documenter.format_module('foo.bar.baz'))
 
156
 
 
157
    def test_format_test_class(self):
 
158
        """The natural language display of a test class name is the class name
 
159
        split up into words with title-case capitalization and with all
 
160
        mentions of 'Test' stripped out.
 
161
        """
 
162
        self.assertEqual('Foo Bar',
 
163
                         self.documenter.format_test_class('TestFooBar'))
 
164
        self.assertEqual('Foo Bar',
 
165
                         self.documenter.format_test_class('FooBarTest'))
 
166
 
 
167
 
 
168
    def test_format_test(self):
 
169
        """The natural language display of a test method name is the name split
 
170
        into words with the initial word (usually 'test') dropped off. The
 
171
        phrase uses title-case capitalization.
 
172
        """
 
173
        self.assertEqual('Janey has a Gun',
 
174
                         self.documenter.format_test('test_janey_has_a_gun'))