← 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: Vincent Ladeuil
  • Date: 2017-01-17 13:48:10 UTC
  • mfrom: (6615.3.6 merges)
  • mto: This revision was merged to the branch mainline in revision 6620.
  • Revision ID: v.ladeuil+lp@free.fr-20170117134810-j9p3lidfy6pfyfsc
Merge 2.7, resolving conflicts

Show diffs side-by-side

added added

removed removed

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