1
=== removed file 'lib/lp/registry/doc/nickname.txt'
2
--- lib/lp/registry/doc/nickname.txt	2010-10-09 16:36:22 +0000
3
+++ lib/lp/registry/doc/nickname.txt	1970-01-01 00:00:00 +0000
4
@@ -1,96 +0,0 @@
5
1
= Nickname =
6
2
7
3
For each Person we create a unique nickname that must be generated using
8
4
generate_nick.
9
5
10
6
A valid nick can contain lower case letters, dashes, and numbers,
11
7
must start with a letter or a number, and must be a minimum of
12
8
four characters.
13
9
14
10
    >>> from lp.registry.model.person import generate_nick
15
11
    >>> generate_nick("foop@example@com")
16
12
    Traceback (most recent call last):
17
13
        ...
18
14
    NicknameGenerationError: foop@example@com is not a valid email address
19
15
    >>> generate_nick("foop@example.com")
20
16
    'foop'
21
17
    >>> generate_nick("bar@example.com")
22
18
    'bar'
23
19
    >>> generate_nick("spam@example.com")
24
20
    'spam'
25
21
    >>> generate_nick("foo.bar@canonical.com")
26
22
    'foo-bar'
27
23
    >>> generate_nick("foo+bar@example.com")
28
24
    'foo+bar'
29
25
    >>> generate_nick("--foo@example.com")
30
26
    'foo'
31
27
32
28
We already have a salgado, so generate_nick needs to try a little harder.
33
29
34
30
    >>> generate_nick("salgado@async.co.br")
35
31
    'salgado-async'
36
32
37
33
And it needs to maintain a minimum length
38
34
39
35
    >>> generate_nick("i@tv")
40
36
    'i-tv'
41
37
42
38
    >>> _counter = 0
43
39
    >>> from zope.security.proxy import removeSecurityProxy
44
40
    >>> def new_person(email):
45
41
    ...     from lp.registry.interfaces.person import IPersonSet
46
42
    ...     from canonical.launchpad.interfaces.emailaddress import IEmailAddressSet
47
43
    ...     from lp.registry.interfaces.person import (
48
44
    ...         PersonCreationRationale)
49
45
    ...     UNKNOWN = PersonCreationRationale.UNKNOWN
50
46
    ...     person_set = getUtility(IPersonSet)
51
47
    ...     person, ignored = person_set.createPersonAndEmail(
52
48
    ...         email, UNKNOWN)
53
49
    ...     # Switch the email to avoid conflicts when generating clashing names
54
50
    ...     email_address_set = getUtility(IEmailAddressSet)
55
51
    ...     global _counter
56
52
    ...     for email_address in email_address_set.getByPerson(person):
57
53
    ...         removeSecurityProxy(email_address).email = (
58
54
    ...             'nodupe%d@example.com' % _counter)
59
55
    ...         _counter += 1
60
56
    ...     flush_database_updates()
61
57
    ...     assert email_address_set.getByEmail(email) is None, 'Oops'
62
58
    ...     return person
63
59
64
60
The email address is used to generate nicknames. If domain is used to
65
61
attempt to avoid clashes.
66
62
67
63
    >>> new_person('bongo@example.com').name
68
64
    u'bongo'
69
65
    >>> new_person('bongo@example.com').name
70
66
    u'bongo-example'
71
67
    >>> new_person('bongo@example.com').name
72
68
    u'bongo-example-com'
73
69
74
70
It should be nearly impossible to make the method fail even in the
75
71
extreme cases where using all components of the domain name fails.
76
72
If nicknames still clash, random suffixes are tried:
77
73
78
74
    >>> new_person('bongo@example.com').name
79
75
    u'bongo-example-com-c'
80
76
81
77
Random prefixes are tried:
82
78
83
79
    >>> new_person('bongo@example.com').name
84
80
    u'q-bongo-example-com'
85
81
86
82
And random mutations are tried:
87
83
88
84
    >>> new_person('bongo@example.com').name
89
85
    u'bongo-examale-com'
90
86
91
87
The only way it can fail is if some idiot admin goes and registers a
92
88
'match-everything' pattern in the blacklist:
93
89
94
90
    >>> from canonical.database.sqlbase import cursor
95
91
    >>> cur = cursor()
96
92
    >>> cur.execute("INSERT INTO NameBlacklist (regexp) VALUES ('.')")
97
93
    >>> generate_nick("foo@example.com")
98
94
    Traceback (most recent call last):
99
95
    ...
100
96
    NicknameGenerationError: No nickname could be generated...
101
97
0
102
=== modified file 'lib/lp/registry/model/person.py'
103
--- lib/lp/registry/model/person.py	2011-05-18 03:36:29 +0000
104
+++ lib/lp/registry/model/person.py	2011-05-24 13:43:18 +0000
105
@@ -4541,9 +4541,8 @@
106
4541
        raise NicknameGenerationError("%s is not a valid email address"
4541
        raise NicknameGenerationError("%s is not a valid email address"
107
4542
                                      % email_addr)
4542
                                      % email_addr)
108
4543
4543
110
4544
    user, domain = re.match("^(\S+)@(\S+)$", email_addr).groups()
4544
    user = re.match("^(\S+)@(?:\S+)$", email_addr).groups()[0]
111
4545
    user = user.replace(".", "-").replace("_", "-")
4545
    user = user.replace(".", "-").replace("_", "-")
112
4546
    domain_parts = domain.split(".")
113
4547
4546
114
4548
    person_set = PersonSet()
4547
    person_set = PersonSet()
115
4549
4548
116
@@ -4561,11 +4560,6 @@
117
4561
    if _valid_nick(generated_nick):
4560
    if _valid_nick(generated_nick):
118
4562
        return generated_nick
4561
        return generated_nick
119
4563
4562
120
4564
    for domain_part in domain_parts:
121
4565
        generated_nick = sanitize_name(generated_nick + "-" + domain_part)
122
4566
        if _valid_nick(generated_nick):
123
4567
            return generated_nick
124
4568
125
4569
    # We seed the random number generator so we get consistent results,
4563
    # We seed the random number generator so we get consistent results,
126
4570
    # making the algorithm repeatable and thus testable.
4564
    # making the algorithm repeatable and thus testable.
127
4571
    random_state = random.getstate()
4565
    random_state = random.getstate()
128
4572
4566
129
=== added file 'lib/lp/registry/tests/test_nickname.py'
130
--- lib/lp/registry/tests/test_nickname.py	1970-01-01 00:00:00 +0000
131
+++ lib/lp/registry/tests/test_nickname.py	2011-05-24 13:43:18 +0000
132
@@ -0,0 +1,74 @@
133
1
# Copyright 2011 Canonical Ltd.  This software is licensed under the
134
2
# GNU Affero General Public License version 3 (see the file LICENSE).
135
3
136
4
"""Tests for nickname generation"""
137
5
138
6
__metaclass__ = type
139
7
140
8
from zope.component import getUtility
141
9
142
10
from canonical.testing.layers import DatabaseFunctionalLayer
143
11
from lp.registry.interfaces.person import IPersonSet
144
12
from lp.registry.model.person import (
145
13
    generate_nick,
146
14
    NicknameGenerationError,
147
15
    )
148
16
from lp.testing import TestCaseWithFactory
149
17
150
18
151
19
class TestNicknameGeneration(TestCaseWithFactory):
152
20
153
21
    layer = DatabaseFunctionalLayer
154
22
155
23
    def test_rejects_invalid_emails(self):
156
24
        # generate_nick rejects invalid email addresses
157
25
        self.assertRaises(
158
26
            NicknameGenerationError,
159
27
            generate_nick,
160
28
            'foo@example@com')
161
29
162
30
    def test_uses_email_address(self):
163
31
        # generate_nick uses the first part of the email address to create
164
32
        # the nick.
165
33
        nick = generate_nick('bar@example.com')
166
34
        self.assertEqual('bar', nick)
167
35
168
36
    def test_handles_symbols(self):
169
37
        # If an email starts with symbols, generate_nick still creates a
170
38
        # valid nick that doesn't start with symbols.
171
39
        nicks = [generate_nick(email) for email in [
172
40
                                            '---bar@example.com',
173
41
                                            'foo.bar@example.com',
174
42
                                            'foo-bar@example.com',
175
43
                                            'foo+bar@example.com',
176
44
                                            ]]
177
45
        self.assertEqual(
178
46
            ['bar', 'foo-bar', 'foo-bar', 'foo+bar'],
179
47
            nicks)
180
48
181
49
    def test_enforces_minimum_length(self):
182
50
        # Nicks must be a minimum length. generate_nick enforces this by 
183
51
        # adding random suffixes to the required length.
184
52
        # The nick 'i' isn't used, so we know any additional prefi
185
53
        person = getUtility(IPersonSet).getByName('i')
186
54
        self.assertIs(None, person)
187
55
        nick = generate_nick('i@example.com')
188
56
        self.assertEqual('i-5', nick)
189
57
190
58
    def test_can_create_noncolliding_nicknames(self):
191
59
        # Given the same email address, generate_nick doesn't recreate the
192
60
        # same nick once that nick is used.
193
61
        self._useNicknames(['bar'])
194
62
        nick = generate_nick('bar@example.com')
195
63
        self.assertEqual('bar-c', nick)
196
64
197
65
        # If we used the previously created nick and get another bar@ email
198
66
        # address, another new nick is generated.
199
67
        self._useNicknames(['bar-c'])
200
68
        nick = generate_nick('bar@example.com')
201
69
        self.assertEqual('a-bar', nick)
202
70
203
71
    def _useNicknames(self, nicknames):
204
72
        # Helper method to consume a nickname
205
73
        for nick in nicknames:
206
74
            self.factory.makePerson(name=nick)
Reviewer	Review Type	Date Requested	Status
Benji York (community)	code	2011-05-23	Approve on 2011-05-23
Review via email: mp+62023@code.launchpad.net