← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/registry/tests/test_prf_walker.py

Merge from devel

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/registry/tests/test_prf_walker.py
1
 
# Copyright 2009 Canonical Ltd.  This software is licensed under the
 
1
# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the
2
2
# GNU Affero General Public License version 3 (see the file LICENSE).
3
3
 
4
4
"""Tests for lp.registry.scripts.productreleasefinder.walker."""
8
8
import unittest
9
9
import urlparse
10
10
 
 
11
 
11
12
from canonical.lazr.utils import safe_hasattr
12
13
from canonical.testing import reset_logging
 
14
from lp.registry.scripts.productreleasefinder.walker import WalkerBase
13
15
from lp.testing import TestCase
14
16
 
15
17
 
17
19
 
18
20
    def testCreatesDefaultLogger(self):
19
21
        """WalkerBase creates a default logger."""
20
 
        from lp.registry.scripts.productreleasefinder.walker import (
21
 
            WalkerBase)
22
22
        from logging import Logger
23
23
        w = WalkerBase("/")
24
24
        self.failUnless(isinstance(w.log, Logger))
25
25
 
26
26
    def testCreatesChildLogger(self):
27
27
        """WalkerBase creates a child logger if given a parent."""
28
 
        from lp.registry.scripts.productreleasefinder.walker import (
29
 
            WalkerBase)
30
28
        from logging import getLogger
31
29
        parent = getLogger("foo")
32
30
        w = WalkerBase("/", log_parent=parent)
37
35
 
38
36
    def testSetsBase(self):
39
37
        """WalkerBase sets the base property."""
40
 
        from lp.registry.scripts.productreleasefinder.walker import (
41
 
            WalkerBase)
42
38
        w = WalkerBase("ftp://localhost/")
43
39
        self.assertEquals(w.base, "ftp://localhost/")
44
40
 
45
41
    def testSetsScheme(self):
46
42
        """WalkerBase sets the scheme property."""
47
 
        from lp.registry.scripts.productreleasefinder.walker import (
48
 
            WalkerBase)
49
43
        w = WalkerBase("ftp://localhost/")
50
44
        self.assertEquals(w.scheme, "ftp")
51
45
 
52
46
    def testSetsHost(self):
53
47
        """WalkerBase sets the host property."""
54
 
        from lp.registry.scripts.productreleasefinder.walker import (
55
 
            WalkerBase)
56
48
        w = WalkerBase("ftp://localhost/")
57
49
        self.assertEquals(w.host, "localhost")
58
50
 
59
51
    def testNoScheme(self):
60
52
        """WalkerBase works when given a URL with no scheme."""
61
 
        from lp.registry.scripts.productreleasefinder.walker import (
62
 
            WalkerBase)
63
53
        w = WalkerBase("/")
64
54
        self.assertEquals(w.host, "")
65
55
 
71
61
 
72
62
    def testUnescapesHost(self):
73
63
        """WalkerBase unescapes the host portion."""
74
 
        from lp.registry.scripts.productreleasefinder.walker import (
75
 
            WalkerBase)
76
64
        w = WalkerBase("ftp://local%40host/")
77
65
        self.assertEquals(w.host, "local@host")
78
66
 
79
67
    def testNoUsername(self):
80
68
        """WalkerBase stores None when there is no username."""
81
 
        from lp.registry.scripts.productreleasefinder.walker import (
82
 
            WalkerBase)
83
69
        w = WalkerBase("ftp://localhost/")
84
70
        self.assertEquals(w.user, None)
85
71
 
86
72
    def testUsername(self):
87
73
        """WalkerBase splits out the username from the host portion."""
88
 
        from lp.registry.scripts.productreleasefinder.walker import (
89
 
            WalkerBase)
90
74
        w = WalkerBase("ftp://scott@localhost/")
91
75
        self.assertEquals(w.user, "scott")
92
76
        self.assertEquals(w.host, "localhost")
93
77
 
94
78
    def testUnescapesUsername(self):
95
79
        """WalkerBase unescapes the username portion."""
96
 
        from lp.registry.scripts.productreleasefinder.walker import (
97
 
            WalkerBase)
98
80
        w = WalkerBase("ftp://scott%3awibble@localhost/")
99
81
        self.assertEquals(w.user, "scott:wibble")
100
82
        self.assertEquals(w.host, "localhost")
101
83
 
102
84
    def testNoPassword(self):
103
85
        """WalkerBase stores None when there is no password."""
104
 
        from lp.registry.scripts.productreleasefinder.walker import (
105
 
            WalkerBase)
106
86
        w = WalkerBase("ftp://scott@localhost/")
107
87
        self.assertEquals(w.passwd, None)
108
88
 
109
89
    def testPassword(self):
110
90
        """WalkerBase splits out the password from the username."""
111
 
        from lp.registry.scripts.productreleasefinder.walker import (
112
 
            WalkerBase)
113
91
        w = WalkerBase("ftp://scott:wibble@localhost/")
114
92
        self.assertEquals(w.user, "scott")
115
93
        self.assertEquals(w.passwd, "wibble")
117
95
 
118
96
    def testUnescapesPassword(self):
119
97
        """WalkerBase unescapes the password portion."""
120
 
        from lp.registry.scripts.productreleasefinder.walker import (
121
 
            WalkerBase)
122
98
        w = WalkerBase("ftp://scott:wibble%20wobble@localhost/")
123
99
        self.assertEquals(w.user, "scott")
124
100
        self.assertEquals(w.passwd, "wibble wobble")
126
102
 
127
103
    def testPathOnly(self):
128
104
        """WalkerBase stores the path if that's all there is."""
129
 
        from lp.registry.scripts.productreleasefinder.walker import (
130
 
            WalkerBase)
131
105
        w = WalkerBase("/path/to/something/")
132
106
        self.assertEquals(w.path, "/path/to/something/")
133
107
 
134
108
    def testPathInUrl(self):
135
109
        """WalkerBase stores the path portion of a complete URL."""
136
 
        from lp.registry.scripts.productreleasefinder.walker import (
137
 
            WalkerBase)
138
110
        w = WalkerBase("ftp://localhost/path/to/something/")
139
111
        self.assertEquals(w.path, "/path/to/something/")
140
112
 
141
113
    def testAddsSlashToPath(self):
142
114
        """WalkerBase adds a trailing slash to path if ommitted."""
143
 
        from lp.registry.scripts.productreleasefinder.walker import (
144
 
            WalkerBase)
145
115
        w = WalkerBase("ftp://localhost/path/to/something")
146
116
        self.assertEquals(w.path, "/path/to/something/")
147
117
 
148
118
    def testUnescapesPath(self):
149
119
        """WalkerBase leaves the path escaped."""
150
 
        from lp.registry.scripts.productreleasefinder.walker import (
151
 
            WalkerBase)
152
120
        w = WalkerBase("ftp://localhost/some%20thing/")
153
121
        self.assertEquals(w.path, "/some%20thing/")
154
122
 
155
123
    def testStoresQuery(self):
156
124
        """WalkerBase stores the query portion of a supporting URL."""
157
 
        from lp.registry.scripts.productreleasefinder.walker import (
158
 
            WalkerBase)
159
125
        w = WalkerBase("http://localhost/?foo")
160
126
        self.assertEquals(w.query, "foo")
161
127
 
162
128
    def testStoresFragment(self):
163
129
        """WalkerBase stores the fragment portion of a supporting URL."""
164
 
        from lp.registry.scripts.productreleasefinder.walker import (
165
 
            WalkerBase)
166
130
        WalkerBase.FRAGMENTS = True
167
131
        try:
168
132
            w = WalkerBase("http://localhost/#foo")
180
144
 
181
145
    def test_walk_UnicodeEncodeError(self):
182
146
        """Verify that a UnicodeEncodeError is logged."""
183
 
        from lp.registry.scripts.productreleasefinder.walker import (
184
 
            WalkerBase)
185
147
 
186
148
        class TestWalker(WalkerBase):
187
149
 
202
164
        logger.setLevel(logging.DEBUG)
203
165
        logger.addHandler(logging.StreamHandler(log_output))
204
166
        walker = TestWalker('http://example.org/foo', logger)
205
 
        for dummy in walker:
206
 
            pass
 
167
        list(walker)
207
168
        self.assertEqual(
208
169
            "Unicode error parsing http://example.org/foo page '/foo/'\n",
209
170
            log_output.getvalue())
210
171
 
 
172
    def test_walk_open_fail(self):
 
173
        # The walker handles an exception raised during open().
 
174
 
 
175
        class TestWalker(WalkerBase):
 
176
 
 
177
            def list(self, sub_dir):
 
178
                pass
 
179
 
 
180
            def open(self):
 
181
                raise IOError("Test failure.")
 
182
 
 
183
            def close(self):
 
184
                pass
 
185
 
 
186
        log_output = StringIO.StringIO()
 
187
        logger = logging.getLogger()
 
188
        self.addCleanup(logger.setLevel, logger.level)
 
189
        logger.setLevel(logging.DEBUG)
 
190
        logger.addHandler(logging.StreamHandler(log_output))
 
191
        walker = TestWalker('ftp://example.org/foo', logger)
 
192
        list(walker)
 
193
        self.assertEqual(
 
194
            "Could not connect to ftp://example.org/foo\n"
 
195
            "Failure: Test failure.\n",
 
196
            log_output.getvalue())
 
197
 
211
198
 
212
199
class FTPWalker_Base(TestCase):
213
200