← Back to branch summary

~justin-fathomdb/nova/justinsb-openstack-api-volumes

« back to all changes in this revision

Viewing changes to vendor/Twisted-10.0.0/twisted/python/test/test_versions.py

  • Committer: Jesse Andrews
  • Date: 2010-05-28 06:05:26 UTC
  • Revision ID: git-v1:bf6e6e718cdc7488e2da87b21e258ccc065fe499
initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/Twisted-10.0.0/twisted/python/test/test_versions.py
 
1
# Copyright (c) 2006-2008 Twisted Matrix Laboratories.
 
2
# See LICENSE for details.
 
3
 
 
4
import sys
 
5
from cStringIO import StringIO
 
6
 
 
7
from twisted.python.versions import getVersionString, IncomparableVersions
 
8
from twisted.python.versions import Version, _inf
 
9
from twisted.python.filepath import FilePath
 
10
 
 
11
from twisted.trial import unittest
 
12
 
 
13
 
 
14
 
 
15
VERSION_4_ENTRIES = """\
 
16
<?xml version="1.0" encoding="utf-8"?>
 
17
<wc-entries
 
18
   xmlns="svn:">
 
19
<entry
 
20
   committed-rev="18210"
 
21
   name=""
 
22
   committed-date="2006-09-21T04:43:09.542953Z"
 
23
   url="svn+ssh://svn.twistedmatrix.com/svn/Twisted/trunk/twisted"
 
24
   last-author="exarkun"
 
25
   kind="dir"
 
26
   uuid="bbbe8e31-12d6-0310-92fd-ac37d47ddeeb"
 
27
   repos="svn+ssh://svn.twistedmatrix.com/svn/Twisted"
 
28
   revision="18211"/>
 
29
</wc-entries>
 
30
"""
 
31
 
 
32
 
 
33
 
 
34
VERSION_8_ENTRIES = """\
 
35
8
 
36
 
 
37
dir
 
38
22715
 
39
svn+ssh://svn.twistedmatrix.com/svn/Twisted/trunk
 
40
"""
 
41
 
 
42
 
 
43
VERSION_9_ENTRIES = """\
 
44
9
 
45
 
 
46
dir
 
47
22715
 
48
svn+ssh://svn.twistedmatrix.com/svn/Twisted/trunk
 
49
"""
 
50
 
 
51
 
 
52
VERSION_10_ENTRIES = """\
 
53
10
 
54
 
 
55
dir
 
56
22715
 
57
svn+ssh://svn.twistedmatrix.com/svn/Twisted/trunk
 
58
"""
 
59
 
 
60
 
 
61
class VersionsTest(unittest.TestCase):
 
62
 
 
63
    def test_versionComparison(self):
 
64
        """
 
65
        Versions can be compared for equality and order.
 
66
        """
 
67
        va = Version("dummy", 1, 0, 0)
 
68
        vb = Version("dummy", 0, 1, 0)
 
69
        self.failUnless(va > vb)
 
70
        self.failUnless(vb < va)
 
71
        self.failUnless(va >= vb)
 
72
        self.failUnless(vb <= va)
 
73
        self.failUnless(va != vb)
 
74
        self.failUnless(vb == Version("dummy", 0, 1, 0))
 
75
        self.failUnless(vb == vb)
 
76
 
 
77
        # BREAK IT DOWN@!!
 
78
        self.failIf(va < vb)
 
79
        self.failIf(vb > va)
 
80
        self.failIf(va <= vb)
 
81
        self.failIf(vb >= va)
 
82
        self.failIf(va == vb)
 
83
        self.failIf(vb != Version("dummy", 0, 1, 0))
 
84
        self.failIf(vb != vb)
 
85
 
 
86
 
 
87
    def test_comparingPrereleasesWithReleases(self):
 
88
        """
 
89
        Prereleases are always less than versions without prereleases.
 
90
        """
 
91
        va = Version("whatever", 1, 0, 0, prerelease=1)
 
92
        vb = Version("whatever", 1, 0, 0)
 
93
        self.assertTrue(va < vb)
 
94
        self.assertFalse(va > vb)
 
95
        self.assertNotEquals(vb, va)
 
96
 
 
97
 
 
98
    def test_comparingPrereleases(self):
 
99
        """
 
100
        The value specified as the prerelease is used in version comparisons.
 
101
        """
 
102
        va = Version("whatever", 1, 0, 0, prerelease=1)
 
103
        vb = Version("whatever", 1, 0, 0, prerelease=2)
 
104
        self.assertTrue(va < vb)
 
105
        self.assertFalse(va > vb)
 
106
        self.assertNotEqual(va, vb)
 
107
 
 
108
 
 
109
    def test_infComparison(self):
 
110
        """
 
111
        L{_inf} is equal to L{_inf}.
 
112
 
 
113
        This is a regression test.
 
114
        """
 
115
        self.assertEquals(_inf, _inf)
 
116
 
 
117
 
 
118
    def testDontAllowBuggyComparisons(self):
 
119
        self.assertRaises(IncomparableVersions,
 
120
                          cmp,
 
121
                          Version("dummy", 1, 0, 0),
 
122
                          Version("dumym", 1, 0, 0))
 
123
 
 
124
 
 
125
    def test_repr(self):
 
126
        """
 
127
        Calling C{repr} on a version returns a human-readable string
 
128
        representation of the version.
 
129
        """
 
130
        self.assertEquals(repr(Version("dummy", 1, 2, 3)),
 
131
                          "Version('dummy', 1, 2, 3)")
 
132
 
 
133
 
 
134
    def test_reprWithPrerelease(self):
 
135
        """
 
136
        Calling C{repr} on a version with a prerelease returns a human-readable
 
137
        string representation of the version including the prerelease.
 
138
        """
 
139
        self.assertEquals(repr(Version("dummy", 1, 2, 3, prerelease=4)),
 
140
                          "Version('dummy', 1, 2, 3, prerelease=4)")
 
141
 
 
142
 
 
143
    def test_str(self):
 
144
        """
 
145
        Calling C{str} on a version returns a human-readable string
 
146
        representation of the version.
 
147
        """
 
148
        self.assertEquals(str(Version("dummy", 1, 2, 3)),
 
149
                          "[dummy, version 1.2.3]")
 
150
 
 
151
 
 
152
    def test_strWithPrerelease(self):
 
153
        """
 
154
        Calling C{str} on a version with a prerelease includes the prerelease.
 
155
        """
 
156
        self.assertEquals(str(Version("dummy", 1, 0, 0, prerelease=1)),
 
157
                          "[dummy, version 1.0.0pre1]")
 
158
 
 
159
 
 
160
    def testShort(self):
 
161
        self.assertEquals(Version('dummy', 1, 2, 3).short(), '1.2.3')
 
162
 
 
163
 
 
164
    def test_goodSVNEntries_4(self):
 
165
        """
 
166
        Version should be able to parse an SVN format 4 entries file.
 
167
        """
 
168
        version = Version("dummy", 1, 0, 0)
 
169
        self.assertEquals(
 
170
            version._parseSVNEntries_4(StringIO(VERSION_4_ENTRIES)), '18211')
 
171
 
 
172
 
 
173
    def test_goodSVNEntries_8(self):
 
174
        """
 
175
        Version should be able to parse an SVN format 8 entries file.
 
176
        """
 
177
        version = Version("dummy", 1, 0, 0)
 
178
        self.assertEqual(
 
179
            version._parseSVNEntries_8(StringIO(VERSION_8_ENTRIES)), '22715')
 
180
        
 
181
        
 
182
    def test_goodSVNEntries_9(self):
 
183
        """
 
184
        Version should be able to parse an SVN format 9 entries file.
 
185
        """
 
186
        version = Version("dummy", 1, 0, 0)
 
187
        self.assertEqual(
 
188
            version._parseSVNEntries_9(StringIO(VERSION_9_ENTRIES)), '22715')
 
189
        
 
190
        
 
191
    def test_goodSVNEntriesTenPlus(self):
 
192
        """
 
193
        Version should be able to parse an SVN format 10 entries file.
 
194
        """
 
195
        version = Version("dummy", 1, 0, 0)
 
196
        self.assertEqual(
 
197
            version._parseSVNEntriesTenPlus(StringIO(VERSION_10_ENTRIES)), '22715')
 
198
 
 
199
 
 
200
    def test_getVersionString(self):
 
201
        """
 
202
        L{getVersionString} returns a string with the package name and the
 
203
        short version number.
 
204
        """
 
205
        self.assertEqual(
 
206
            'Twisted 8.0.0', getVersionString(Version('Twisted', 8, 0, 0)))
 
207
 
 
208
 
 
209
    def test_getVersionStringWithPrerelease(self):
 
210
        """
 
211
        L{getVersionString} includes the prerelease, if any.
 
212
        """
 
213
        self.assertEqual(
 
214
            getVersionString(Version("whatever", 8, 0, 0, prerelease=1)),
 
215
            "whatever 8.0.0pre1")
 
216
 
 
217
 
 
218
    def test_base(self):
 
219
        """
 
220
        The L{base} method returns a very simple representation of the version.
 
221
        """
 
222
        self.assertEquals(Version("foo", 1, 0, 0).base(), "1.0.0")
 
223
 
 
224
 
 
225
    def test_baseWithPrerelease(self):
 
226
        """
 
227
        The base version includes 'preX' for versions with prereleases.
 
228
        """
 
229
        self.assertEquals(Version("foo", 1, 0, 0, prerelease=8).base(),
 
230
                          "1.0.0pre8")
 
231
 
 
232
 
 
233
 
 
234
class FormatDiscoveryTests(unittest.TestCase):
 
235
    """
 
236
    Tests which discover the parsing method based on the imported module name.
 
237
    """
 
238
 
 
239
    def setUp(self):
 
240
        """
 
241
        Create a temporary directory with a package structure in it.
 
242
        """
 
243
        self.entry = FilePath(self.mktemp())
 
244
        self.preTestModules = sys.modules.copy()
 
245
        sys.path.append(self.entry.path)
 
246
        pkg = self.entry.child("twisted_python_versions_package")
 
247
        pkg.makedirs()
 
248
        pkg.child("__init__.py").setContent(
 
249
            "from twisted.python.versions import Version\n"
 
250
            "version = Version('twisted_python_versions_package', 1, 0, 0)\n")
 
251
        self.svnEntries = pkg.child(".svn")
 
252
        self.svnEntries.makedirs()
 
253
 
 
254
 
 
255
    def tearDown(self):
 
256
        """
 
257
        Remove the imported modules and sys.path modifications.
 
258
        """
 
259
        sys.modules.clear()
 
260
        sys.modules.update(self.preTestModules)
 
261
        sys.path.remove(self.entry.path)
 
262
 
 
263
 
 
264
    def checkSVNFormat(self, formatVersion, entriesText, expectedRevision):
 
265
        """
 
266
        Check for the given revision being detected after setting the SVN
 
267
        entries text and format version of the test directory structure.
 
268
        """
 
269
        self.svnEntries.child("format").setContent(formatVersion+"\n")
 
270
        self.svnEntries.child("entries").setContent(entriesText)
 
271
        self.assertEqual(self.getVersion()._getSVNVersion(), expectedRevision)
 
272
 
 
273
 
 
274
    def getVersion(self):
 
275
        """
 
276
        Import and retrieve the Version object from our dynamically created
 
277
        package.
 
278
        """
 
279
        import twisted_python_versions_package
 
280
        return twisted_python_versions_package.version
 
281
 
 
282
 
 
283
    def test_detectVersion4(self):
 
284
        """
 
285
        Verify that version 4 format file will be properly detected and parsed.
 
286
        """
 
287
        self.checkSVNFormat("4", VERSION_4_ENTRIES, '18211')
 
288
 
 
289
 
 
290
    def test_detectVersion8(self):
 
291
        """
 
292
        Verify that version 8 format files will be properly detected and
 
293
        parsed.
 
294
        """
 
295
        self.checkSVNFormat("8", VERSION_8_ENTRIES, '22715')
 
296
        
 
297
    
 
298
    def test_detectVersion9(self):
 
299
        """
 
300
        Verify that version 9 format files will be properly detected and
 
301
        parsed.
 
302
        """
 
303
        self.checkSVNFormat("9", VERSION_9_ENTRIES, '22715')
 
304
        
 
305
        
 
306
    def test_detectVersion10(self):
 
307
        """
 
308
        Verify that version 10 format files will be properly detected and
 
309
        parsed.
 
310
 
 
311
        Differing from previous formats, the version 10 format lacks a
 
312
        I{format} file and B{only} has the version information on the first
 
313
        line of the I{entries} file.
 
314
        """
 
315
        self.svnEntries.child("entries").setContent(VERSION_10_ENTRIES)
 
316
        self.assertEquals(self.getVersion()._getSVNVersion(), '22715')
 
317
 
 
318
 
 
319
    def test_detectUnknownVersion(self):
 
320
        """
 
321
        Verify that a new version of SVN will result in the revision 'Unknown'.
 
322
        """
 
323
        self.checkSVNFormat("some-random-new-version", "ooga booga!", 'Unknown')