← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/plugins/launchpad/test_register.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-08 08:15:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101008081514-dviqzrdfwyzsqbz2
Split NEWS into per-release doc/en/release-notes/bzr-*.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/test_register.py
1
 
# Copyright (C) 2006-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import base64
 
18
import os
18
19
from StringIO import StringIO
19
20
import urlparse
20
21
import xmlrpclib
21
22
 
22
23
from bzrlib import (
23
24
    config,
 
25
    osutils,
24
26
    tests,
25
27
    ui,
26
28
    )
27
 
from bzrlib.tests import TestCaseWithTransport
 
29
from bzrlib.tests import TestCaseWithTransport, TestSkipped
28
30
 
29
31
# local import
30
32
from bzrlib.plugins.launchpad.lp_registration import (
59
61
        """
60
62
        return (200, 'OK', [])
61
63
 
62
 
    def getresponse(self, buffering=True):
63
 
        """Fake the http reply.
64
 
 
65
 
        This is used when running on Python 2.7, where xmlrpclib uses
66
 
        httplib.HTTPConnection in a different way than before.
67
 
        """
68
 
        class FakeHttpResponse(object):
69
 
 
70
 
            def __init__(self, status, reason, body):
71
 
                self.status = status
72
 
                self.reason = reason
73
 
                self.body = body
74
 
 
75
 
            def read(self, size=-1):
76
 
                return self.body.read(size)
77
 
 
78
 
            def getheader(self, name, default):
79
 
                # We don't have headers
80
 
                return default
81
 
 
82
 
        return FakeHttpResponse(200, 'OK', self.getfile())
83
 
 
84
64
    def getfile(self):
85
65
        """Return a fake file containing the response content."""
86
66
        return StringIO('''\
105
85
    def __init__(self, testcase, expect_auth):
106
86
        self.testcase = testcase
107
87
        self.expect_auth = expect_auth
108
 
        self._connection = (None, None)
109
88
 
110
89
    def make_connection(self, host):
111
90
        host, http_headers, x509 = self.get_host_info(host)
118
97
                    % (auth_hdrs,))
119
98
            authinfo = auth_hdrs[0]
120
99
            expected_auth = 'testuser@launchpad.net:testpassword'
121
 
            test.assertEqual(authinfo,
 
100
            test.assertEquals(authinfo,
122
101
                    'Basic ' + base64.encodestring(expected_auth).strip())
123
102
        elif http_headers:
124
103
            raise AssertionError()
154
133
 
155
134
 
156
135
class TestBranchRegistration(TestCaseWithTransport):
 
136
    SAMPLE_URL = 'http://bazaar-vcs.org/bzr/bzr.dev/'
 
137
    SAMPLE_OWNER = 'jhacker@foo.com'
 
138
    SAMPLE_BRANCH_ID = 'bzr.dev'
157
139
 
158
140
    def setUp(self):
159
141
        super(TestBranchRegistration, self).setUp()
160
142
        # make sure we have a reproducible standard environment
161
 
        self.overrideEnv('BZR_LP_XMLRPC_URL', None)
 
143
        self._captureVar('BZR_LP_XMLRPC_URL', None)
162
144
 
163
145
    def test_register_help(self):
164
146
        """register-branch accepts --help"""
190
172
        out, err = self.run_bzr(['register-branch',
191
173
                                'http://test-server.com/bzr/branch',
192
174
                                '--dry-run'])
193
 
        self.assertEqual(out, 'Branch registered.\n')
 
175
        self.assertEquals(out, 'Branch registered.\n')
194
176
 
195
177
    def test_onto_transport(self):
196
 
        """How the request is sent by transmitting across a mock Transport"""
 
178
        """Test how the request is sent by transmitting across a mock Transport"""
197
179
        # use a real transport, but intercept at the http/xml layer
198
180
        transport = InstrumentedXMLRPCTransport(self, expect_auth=True)
199
181
        service = LaunchpadService(transport)
206
188
                'author@launchpad.net',
207
189
                'product')
208
190
        rego.submit(service)
209
 
        self.assertEqual(transport.connected_host, 'xmlrpc.launchpad.net')
210
 
        self.assertEqual(len(transport.sent_params), 6)
211
 
        self.assertEqual(transport.sent_params,
 
191
        self.assertEquals(transport.connected_host, 'xmlrpc.launchpad.net')
 
192
        self.assertEquals(len(transport.sent_params), 6)
 
193
        self.assertEquals(transport.sent_params,
212
194
                ('http://test-server.com/bzr/branch',  # branch_url
213
195
                 'branch-id',                          # branch_name
214
196
                 'my test branch',                     # branch_title
218
200
        self.assertTrue(transport.got_request)
219
201
 
220
202
    def test_onto_transport_unauthenticated(self):
221
 
        """An unauthenticated request is transmitted across a mock Transport"""
 
203
        """Test how an unauthenticated request is transmitted across a mock Transport"""
222
204
        transport = InstrumentedXMLRPCTransport(self, expect_auth=False)
223
205
        service = LaunchpadService(transport)
224
206
        resolve = ResolveLaunchpadPathRequest('bzr')
225
207
        resolve.submit(service)
226
 
        self.assertEqual(transport.connected_host, 'xmlrpc.launchpad.net')
227
 
        self.assertEqual(len(transport.sent_params), 1)
228
 
        self.assertEqual(transport.sent_params, ('bzr', ))
 
208
        self.assertEquals(transport.connected_host, 'xmlrpc.launchpad.net')
 
209
        self.assertEquals(len(transport.sent_params), 1)
 
210
        self.assertEquals(transport.sent_params, ('bzr', ))
229
211
        self.assertTrue(transport.got_request)
230
212
 
231
213
    def test_subclass_request(self):
240
222
        service.registrant_password = ''
241
223
        request = DummyRequest()
242
224
        request.submit(service)
243
 
        self.assertEqual(service.called_method_name, 'dummy_request')
244
 
        self.assertEqual(service.called_method_params, (42,))
 
225
        self.assertEquals(service.called_method_name, 'dummy_request')
 
226
        self.assertEquals(service.called_method_params, (42,))
245
227
 
246
228
    def test_mock_server_registration(self):
247
229
        """Send registration to mock server"""
248
230
        test_case = self
249
231
        class MockRegistrationService(MockLaunchpadService):
250
232
            def send_request(self, method_name, method_params, authenticated):
251
 
                test_case.assertEqual(method_name, "register_branch")
252
 
                test_case.assertEqual(list(method_params),
 
233
                test_case.assertEquals(method_name, "register_branch")
 
234
                test_case.assertEquals(list(method_params),
253
235
                        ['url', 'name', 'title', 'description', 'email', 'name'])
254
 
                test_case.assertEqual(authenticated, True)
 
236
                test_case.assertEquals(authenticated, True)
255
237
                return 'result'
256
238
        service = MockRegistrationService()
257
239
        rego = BranchRegistrationRequest('url', 'name', 'title',
258
240
                        'description', 'email', 'name')
259
241
        result = rego.submit(service)
260
 
        self.assertEqual(result, 'result')
 
242
        self.assertEquals(result, 'result')
261
243
 
262
244
    def test_mock_server_registration_with_defaults(self):
263
245
        """Send registration to mock server"""
264
246
        test_case = self
265
247
        class MockRegistrationService(MockLaunchpadService):
266
248
            def send_request(self, method_name, method_params, authenticated):
267
 
                test_case.assertEqual(method_name, "register_branch")
268
 
                test_case.assertEqual(list(method_params),
 
249
                test_case.assertEquals(method_name, "register_branch")
 
250
                test_case.assertEquals(list(method_params),
269
251
                        ['http://server/branch', 'branch', '', '', '', ''])
270
 
                test_case.assertEqual(authenticated, True)
 
252
                test_case.assertEquals(authenticated, True)
271
253
                return 'result'
272
254
        service = MockRegistrationService()
273
255
        rego = BranchRegistrationRequest('http://server/branch')
274
256
        result = rego.submit(service)
275
 
        self.assertEqual(result, 'result')
 
257
        self.assertEquals(result, 'result')
276
258
 
277
259
    def test_mock_bug_branch_link(self):
278
260
        """Send bug-branch link to mock server"""
279
261
        test_case = self
280
262
        class MockService(MockLaunchpadService):
281
263
            def send_request(self, method_name, method_params, authenticated):
282
 
                test_case.assertEqual(method_name, "link_branch_to_bug")
283
 
                test_case.assertEqual(list(method_params),
 
264
                test_case.assertEquals(method_name, "link_branch_to_bug")
 
265
                test_case.assertEquals(list(method_params),
284
266
                        ['http://server/branch', 1234, ''])
285
 
                test_case.assertEqual(authenticated, True)
 
267
                test_case.assertEquals(authenticated, True)
286
268
                return 'http://launchpad.net/bug/1234'
287
269
        service = MockService()
288
270
        rego = BranchBugLinkRequest('http://server/branch', 1234)
289
271
        result = rego.submit(service)
290
 
        self.assertEqual(result, 'http://launchpad.net/bug/1234')
 
272
        self.assertEquals(result, 'http://launchpad.net/bug/1234')
291
273
 
292
274
    def test_mock_resolve_lp_url(self):
293
275
        test_case = self
294
276
        class MockService(MockLaunchpadService):
295
277
            def send_request(self, method_name, method_params, authenticated):
296
 
                test_case.assertEqual(method_name, "resolve_lp_path")
297
 
                test_case.assertEqual(list(method_params), ['bzr'])
298
 
                test_case.assertEqual(authenticated, False)
 
278
                test_case.assertEquals(method_name, "resolve_lp_path")
 
279
                test_case.assertEquals(list(method_params), ['bzr'])
 
280
                test_case.assertEquals(authenticated, False)
299
281
                return dict(urls=[
300
282
                        'bzr+ssh://bazaar.launchpad.net~bzr/bzr/trunk',
301
283
                        'sftp://bazaar.launchpad.net~bzr/bzr/trunk',
305
287
        resolve = ResolveLaunchpadPathRequest('bzr')
306
288
        result = resolve.submit(service)
307
289
        self.assertTrue('urls' in result)
308
 
        self.assertEqual(result['urls'], [
 
290
        self.assertEquals(result['urls'], [
309
291
                'bzr+ssh://bazaar.launchpad.net~bzr/bzr/trunk',
310
292
                'sftp://bazaar.launchpad.net~bzr/bzr/trunk',
311
293
                'bzr+http://bazaar.launchpad.net~bzr/bzr/trunk',
317
299
    def setUp(self):
318
300
        super(TestGatherUserCredentials, self).setUp()
319
301
        # make sure we have a reproducible standard environment
320
 
        self.overrideEnv('BZR_LP_XMLRPC_URL', None)
 
302
        self._captureVar('BZR_LP_XMLRPC_URL', None)
321
303
 
322
304
    def test_gather_user_credentials_has_password(self):
323
305
        service = LaunchpadService()
329
311
    def test_gather_user_credentials_from_auth_conf(self):
330
312
        auth_path = config.authentication_config_filename()
331
313
        service = LaunchpadService()
332
 
        g_conf = config.GlobalStack()
333
 
        g_conf.set('email', 'Test User <test@user.com>')
334
 
        g_conf.store.save()
335
 
        # FIXME: auth_path base dir exists only because bazaar.conf has just
336
 
        # been saved, brittle... -- vila 20120731
 
314
        g_conf = config.GlobalConfig()
 
315
        g_conf.set_user_option('email', 'Test User <test@user.com>')
337
316
        f = open(auth_path, 'wb')
338
317
        try:
339
318
            scheme, hostinfo = urlparse.urlsplit(service.service_url)[:2]
353
332
    def test_gather_user_credentials_prompts(self):
354
333
        service = LaunchpadService()
355
334
        self.assertIs(None, service.registrant_password)
356
 
        g_conf = config.GlobalStack()
357
 
        g_conf.set('email', 'Test User <test@user.com>')
358
 
        g_conf.store.save()
 
335
        g_conf = config.GlobalConfig()
 
336
        g_conf.set_user_option('email', 'Test User <test@user.com>')
359
337
        stdout = tests.StringIOWrapper()
360
338
        stderr = tests.StringIOWrapper()
361
339
        ui.ui_factory = tests.TestUIFactory(stdin='userpass\n',
364
342
        service.gather_user_credentials()
365
343
        self.assertEqual('test@user.com', service.registrant_email)
366
344
        self.assertEqual('userpass', service.registrant_password)
367
 
        self.assertEqual('', stdout.getvalue())
 
345
        self.assertEquals('', stdout.getvalue())
368
346
        self.assertContainsRe(stderr.getvalue(),
369
347
                             'launchpad.net password for test@user\\.com')
370
348