/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_mail_client.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-18 22:34:21 UTC
  • mto: (3606.5.6 1.6)
  • mto: This revision was merged to the branch mainline in revision 3641.
  • Revision ID: john@arbash-meinel.com-20080818223421-todjny24vj4faj4t
Add tests for the fetching behavior.

The proper parameter passed is 'unordered' add an assert for it, and
fix callers that were passing 'unsorted' instead.
Add tests that we make the right get_record_stream call based
on the value of _fetch_uses_deltas.
Fix the fetch request for signatures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_mail_client.py
 
1
# Copyright (C) 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from bzrlib import (
 
18
    errors,
 
19
    mail_client,
 
20
    tests,
 
21
    urlutils,
 
22
    )
 
23
 
 
24
class TestMutt(tests.TestCase):
 
25
 
 
26
    def test_commandline(self):
 
27
        mutt = mail_client.Mutt(None)
 
28
        commandline = mutt._get_compose_commandline(None, None, 'file%')
 
29
        self.assertEqual(['-a', 'file%'], commandline)
 
30
        commandline = mutt._get_compose_commandline('jrandom@example.org',
 
31
                                                     'Hi there!', None)
 
32
        self.assertEqual(['-s', 'Hi there!', 'jrandom@example.org'],
 
33
                         commandline)
 
34
 
 
35
    def test_commandline_is_8bit(self):
 
36
        mutt = mail_client.Mutt(None)
 
37
        cmdline = mutt._get_compose_commandline(u'jrandom@example.org',
 
38
            u'Hi there!', u'file%')
 
39
        self.assertEqual(
 
40
            ['-s', 'Hi there!', '-a', 'file%', 'jrandom@example.org'],
 
41
            cmdline)
 
42
        for item in cmdline:
 
43
            self.assertFalse(isinstance(item, unicode),
 
44
                'Command-line item %r is unicode!' % item)
 
45
 
 
46
 
 
47
class TestThunderbird(tests.TestCase):
 
48
 
 
49
    def test_commandline(self):
 
50
        tbird = mail_client.Thunderbird(None)
 
51
        commandline = tbird._get_compose_commandline(None, None,
 
52
                                                     'file%')
 
53
        self.assertEqual(['-compose', "attachment='%s'" %
 
54
                          urlutils.local_path_to_url('file%')], commandline)
 
55
        commandline = tbird._get_compose_commandline('jrandom@example.org',
 
56
                                                     'Hi there!', None)
 
57
        self.assertEqual(['-compose', "subject='Hi there!',"
 
58
                                      "to='jrandom@example.org'"], commandline)
 
59
 
 
60
    def test_commandline_is_8bit(self):
 
61
        # test for bug #139318
 
62
        tbird = mail_client.Thunderbird(None)
 
63
        cmdline = tbird._get_compose_commandline(u'jrandom@example.org',
 
64
            u'Hi there!', u'file%')
 
65
        self.assertEqual(['-compose',
 
66
            ("attachment='%s'," % urlutils.local_path_to_url('file%')) +
 
67
            "subject='Hi there!',to='jrandom@example.org'",
 
68
            ], cmdline)
 
69
        for item in cmdline:
 
70
            self.assertFalse(isinstance(item, unicode),
 
71
                'Command-line item %r is unicode!' % item)
 
72
 
 
73
 
 
74
class TestEmacsMail(tests.TestCase):
 
75
 
 
76
    def test_commandline(self):
 
77
        eclient = mail_client.EmacsMail(None)
 
78
 
 
79
        commandline = eclient._get_compose_commandline(None, 'Hi there!', None)
 
80
        self.assertEqual(['--eval', '(compose-mail nil "Hi there!")'],
 
81
                         commandline)
 
82
 
 
83
        commandline = eclient._get_compose_commandline('jrandom@example.org',
 
84
                                                       'Hi there!', None)
 
85
        self.assertEqual(['--eval',
 
86
                          '(compose-mail "jrandom@example.org" "Hi there!")'],
 
87
                         commandline)
 
88
 
 
89
        # We won't be able to know the temporary file name at this stage
 
90
        # so we can't raise an assertion with assertEqual
 
91
        cmdline = eclient._get_compose_commandline(None, None, 'file%')
 
92
        commandline = ' '.join(cmdline)
 
93
        self.assertContainsRe(commandline, '--eval')
 
94
        self.assertContainsRe(commandline, '(compose-mail nil nil)')
 
95
        self.assertContainsRe(commandline, '(load .*)')
 
96
        self.assertContainsRe(commandline, '(bzr-add-mime-att \"file%\")')
 
97
 
 
98
    def test_commandline_is_8bit(self):
 
99
        eclient = mail_client.EmacsMail(None)
 
100
        commandline = eclient._get_compose_commandline(u'jrandom@example.org',
 
101
            u'Hi there!', u'file%')
 
102
        for item in commandline:
 
103
            self.assertFalse(isinstance(item, unicode),
 
104
                'Command-line item %r is unicode!' % item)
 
105
 
 
106
 
 
107
class TestXDGEmail(tests.TestCase):
 
108
 
 
109
    def test_commandline(self):
 
110
        xdg_email = mail_client.XDGEmail(None)
 
111
        self.assertRaises(errors.NoMailAddressSpecified,
 
112
                          xdg_email._get_compose_commandline,
 
113
                          None, None, 'file%')
 
114
        commandline = xdg_email._get_compose_commandline(
 
115
            'jrandom@example.org', None, 'file%')
 
116
        self.assertEqual(['jrandom@example.org', '--attach', 'file%'],
 
117
                         commandline)
 
118
        commandline = xdg_email._get_compose_commandline(
 
119
            'jrandom@example.org', 'Hi there!', None)
 
120
        self.assertEqual(['jrandom@example.org', '--subject', 'Hi there!'],
 
121
                         commandline)
 
122
 
 
123
    def test_commandline_is_8bit(self):
 
124
        xdg_email = mail_client.XDGEmail(None)
 
125
        cmdline = xdg_email._get_compose_commandline(u'jrandom@example.org',
 
126
            u'Hi there!', u'file%')
 
127
        self.assertEqual(
 
128
            ['jrandom@example.org', '--subject', 'Hi there!',
 
129
             '--attach', 'file%'],
 
130
            cmdline)
 
131
        for item in cmdline:
 
132
            self.assertFalse(isinstance(item, unicode),
 
133
                'Command-line item %r is unicode!' % item)
 
134
 
 
135
 
 
136
class TestEvolution(tests.TestCase):
 
137
 
 
138
    def test_commandline(self):
 
139
        evo = mail_client.Evolution(None)
 
140
        commandline = evo._get_compose_commandline(None, None, 'file%')
 
141
        self.assertEqual(['mailto:?attach=file%25'], commandline)
 
142
        commandline = evo._get_compose_commandline('jrandom@example.org',
 
143
                                                   'Hi there!', None)
 
144
        self.assertEqual(['mailto:jrandom@example.org?subject=Hi%20there%21'],
 
145
                         commandline)
 
146
 
 
147
    def test_commandline_is_8bit(self):
 
148
        evo = mail_client.Evolution(None)
 
149
        cmdline = evo._get_compose_commandline(u'jrandom@example.org',
 
150
            u'Hi there!', u'file%')
 
151
        self.assertEqual(
 
152
            ['mailto:jrandom@example.org?attach=file%25&subject=Hi%20there%21'
 
153
            ],
 
154
            cmdline)
 
155
        for item in cmdline:
 
156
            self.assertFalse(isinstance(item, unicode),
 
157
                'Command-line item %r is unicode!' % item)
 
158
 
 
159
 
 
160
class TestKMail(tests.TestCase):
 
161
 
 
162
    def test_commandline(self):
 
163
        kmail = mail_client.KMail(None)
 
164
        commandline = kmail._get_compose_commandline(None, None, 'file%')
 
165
        self.assertEqual(['--attach', 'file%'], commandline)
 
166
        commandline = kmail._get_compose_commandline('jrandom@example.org',
 
167
                                                     'Hi there!', None)
 
168
        self.assertEqual(['-s', 'Hi there!', 'jrandom@example.org'],
 
169
                         commandline)
 
170
 
 
171
    def test_commandline_is_8bit(self):
 
172
        kmail = mail_client.KMail(None)
 
173
        cmdline = kmail._get_compose_commandline(u'jrandom@example.org',
 
174
            u'Hi there!', u'file%')
 
175
        self.assertEqual(
 
176
            ['-s', 'Hi there!', '--attach', 'file%', 'jrandom@example.org'],
 
177
            cmdline)
 
178
        for item in cmdline:
 
179
            self.assertFalse(isinstance(item, unicode),
 
180
                'Command-line item %r is unicode!' % item)
 
181
 
 
182
 
 
183
class TestEditor(tests.TestCase):
 
184
 
 
185
    def test_get_merge_prompt_unicode(self):
 
186
        """Prompt, to and subject are unicode, the attachement is binary"""
 
187
        editor = mail_client.Editor(None)
 
188
        prompt = editor._get_merge_prompt(u'foo\u1234',
 
189
                                        u'bar\u1234',
 
190
                                        u'baz\u1234',
 
191
                                        u'qux\u1234'.encode('utf-8'))
 
192
        self.assertContainsRe(prompt, u'foo\u1234(.|\n)*bar\u1234'
 
193
                              u'(.|\n)*baz\u1234(.|\n)*qux\u1234')
 
194
        editor._get_merge_prompt(u'foo', u'bar', u'baz', 'qux\xff')
 
195
 
 
196
 
 
197
class DummyMailClient(object):
 
198
 
 
199
    def compose_merge_request(self, *args, **kwargs):
 
200
        self.args = args
 
201
        self.kwargs = kwargs
 
202
 
 
203
 
 
204
class DefaultMailDummyClient(mail_client.DefaultMail):
 
205
 
 
206
    def __init__(self):
 
207
        self.client = DummyMailClient()
 
208
 
 
209
    def _mail_client(self):
 
210
        return self.client
 
211
 
 
212
 
 
213
class TestDefaultMail(tests.TestCase):
 
214
 
 
215
    def test_compose_merge_request(self):
 
216
        client = DefaultMailDummyClient()
 
217
        to = "a@b.com"
 
218
        subject = "[MERGE]"
 
219
        directive = "directive",
 
220
        basename = "merge"
 
221
        client.compose_merge_request(to, subject, directive,
 
222
                                     basename=basename)
 
223
        dummy_client = client.client
 
224
        self.assertEqual(dummy_client.args, (to, subject, directive))
 
225
        self.assertEqual(dummy_client.kwargs, {"basename":basename})