← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

Merge from bzr.ab

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
21
21
import unittest
22
22
import warnings
23
23
 
 
24
import bzrlib
24
25
from bzrlib.tests import (
25
26
                          _load_module_by_name,
 
27
                          ChrootedTestCase,
26
28
                          TestCase,
27
29
                          TestCaseInTempDir,
 
30
                          TestCaseWithTransport,
28
31
                          TestSkipped,
29
32
                          TextTestRunner,
30
33
                          )
80
83
class TestTransportProviderAdapter(TestCase):
81
84
    """A group of tests that test the transport implementation adaption core.
82
85
 
 
86
    This is a meta test that the tests are applied to all available 
 
87
    transports.
 
88
 
83
89
    This will be generalised in the future which is why it is in this 
84
90
    test file even though it is specific to transport tests at the moment.
85
91
    """
127
133
        # that it does not just use the same one all the time.
128
134
        # and that the id is set correctly so that debugging is
129
135
        # easy.
 
136
        # 
 
137
        # An instance of this test is actually used as the input
 
138
        # for adapting it to all the available transports
 
139
        # (or i think so - ??? mbp)
130
140
        from bzrlib.transport.local import (LocalTransport,
131
141
                                            LocalRelpathServer,
132
142
                                            LocalAbspathServer,
167
177
        input_test = TestTransportProviderAdapter(
168
178
            "test_adapter_sets_transport_class")
169
179
        suite = TransportTestProviderAdapter().adapt(input_test)
 
180
        # tests are generated in collation order. 
 
181
        # XXX: but i'm not sure the order should really be part of the 
 
182
        # contract of the adapter, should it -- mbp 20060201
170
183
        test_iter = iter(suite)
171
184
        http_test = test_iter.next()
172
185
        local_relpath_test = test_iter.next()
173
186
        local_abspath_test = test_iter.next()
174
187
        local_urlpath_test = test_iter.next()
175
188
        memory_test = test_iter.next()
 
189
        readonly_test = test_iter.next()
176
190
        if has_paramiko:
177
191
            sftp_abs_test = test_iter.next()
178
192
            sftp_homedir_test = test_iter.next()
179
193
            sftp_sibling_abs_test = test_iter.next()
180
194
        # ftp_test = test_iter.next()
 
195
        # should now be at the end of the test
181
196
        self.assertRaises(StopIteration, test_iter.next)
182
197
        self.assertEqual(LocalTransport, local_relpath_test.transport_class)
183
198
        self.assertEqual(LocalRelpathServer, local_relpath_test.transport_server)
213
228
                         "TestTransportProviderAdapter."
214
229
                         "test_adapter_sets_transport_class(LocalRelpathServer)",
215
230
                         local_relpath_test.id())
 
231
 
 
232
 
 
233
class TestBranchProviderAdapter(TestCase):
 
234
    """A group of tests that test the branch implementation test adapter."""
 
235
 
 
236
    def test_adapted_tests(self):
 
237
        # check that constructor parameters are passed through to the adapted
 
238
        # test.
 
239
        from bzrlib.branch import BranchTestProviderAdapter
 
240
        input_test = TestBranchProviderAdapter(
 
241
            "test_adapted_tests")
 
242
        server1 = "a"
 
243
        server2 = "b"
 
244
        formats = ["c", "d"]
 
245
        adapter = BranchTestProviderAdapter(server1, server2, formats)
 
246
        suite = adapter.adapt(input_test)
 
247
        tests = list(iter(suite))
 
248
        self.assertEqual(2, len(tests))
 
249
        self.assertEqual(tests[0].branch_format, formats[0])
 
250
        self.assertEqual(tests[0].transport_server, server1)
 
251
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
252
        self.assertEqual(tests[1].branch_format, formats[1])
 
253
        self.assertEqual(tests[1].transport_server, server1)
 
254
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
255
 
 
256
 
 
257
class TestTestCaseWithTransport(TestCaseWithTransport):
 
258
    """Tests for the convenience functions TestCaseWithTransport introduces."""
 
259
 
 
260
    def test_get_readonly_url_none(self):
 
261
        from bzrlib.transport import get_transport
 
262
        from bzrlib.transport.memory import MemoryServer
 
263
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
 
264
        self.transport_server = MemoryServer
 
265
        self.transport_readonly_server = None
 
266
        # calling get_readonly_transport() constructs a decorator on the url
 
267
        # for the server
 
268
        url = self.get_readonly_url()
 
269
        url2 = self.get_readonly_url('foo/bar')
 
270
        t = get_transport(url)
 
271
        t2 = get_transport(url2)
 
272
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
 
273
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
 
274
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
 
275
 
 
276
    def test_get_readonly_url_http(self):
 
277
        from bzrlib.transport import get_transport
 
278
        from bzrlib.transport.local import LocalRelpathServer
 
279
        from bzrlib.transport.http import HttpServer, HttpTransport
 
280
        self.transport_server = LocalRelpathServer
 
281
        self.transport_readonly_server = HttpServer
 
282
        # calling get_readonly_transport() gives us a HTTP server instance.
 
283
        url = self.get_readonly_url()
 
284
        url2 = self.get_readonly_url('foo/bar')
 
285
        t = get_transport(url)
 
286
        t2 = get_transport(url2)
 
287
        self.failUnless(isinstance(t, HttpTransport))
 
288
        self.failUnless(isinstance(t2, HttpTransport))
 
289
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
 
290
 
 
291
 
 
292
class TestChrootedTest(ChrootedTestCase):
 
293
 
 
294
    def test_root_is_root(self):
 
295
        from bzrlib.transport import get_transport
 
296
        t = get_transport(self.get_readonly_url())
 
297
        url = t.base
 
298
        self.assertEqual(url, t.clone('..').base)