/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 breezy/tests/test_rio.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_rio.py
47
47
        self.assertFalse('color' in s)
48
48
        self.assertFalse('42' in s)
49
49
        self.assertEqual(list(s.iter_pairs()),
50
 
                         [('name', 'fred'), ('number', '42')])
 
50
                [('name', 'fred'), ('number', '42')])
51
51
        self.assertEqual(s.get('number'), '42')
52
52
        self.assertEqual(s.get('name'), 'fred')
53
53
 
55
55
        """Serialize stanza with empty field"""
56
56
        s = Stanza(empty='')
57
57
        self.assertEquals(s.to_string(),
58
 
                          b"empty: \n")
 
58
                b"empty: \n")
59
59
 
60
60
    def test_to_lines(self):
61
61
        """Write simple rio stanza to string"""
62
62
        s = Stanza(number='42', name='fred')
63
63
        self.assertEqual(list(s.to_lines()),
64
 
                         [b'name: fred\n',
65
 
                          b'number: 42\n'])
 
64
                [b'name: fred\n',
 
65
                 b'number: 42\n'])
66
66
 
67
67
    def test_as_dict(self):
68
68
        """Convert rio Stanza to dictionary"""
73
73
    def test_to_file(self):
74
74
        """Write rio to file"""
75
75
        tmpf = TemporaryFile()
76
 
        s = Stanza(a_thing='something with "quotes like \\"this\\""',
77
 
                   number='42', name='fred')
 
76
        s = Stanza(a_thing='something with "quotes like \\"this\\""', number='42', name='fred')
78
77
        s.write(tmpf)
79
78
        tmpf.seek(0)
80
79
        self.assertEqual(tmpf.read(), b'''\
85
84
 
86
85
    def test_multiline_string(self):
87
86
        tmpf = TemporaryFile()
88
 
        s = Stanza(
89
 
            motto="war is peace\nfreedom is slavery\nignorance is strength")
 
87
        s = Stanza(motto="war is peace\nfreedom is slavery\nignorance is strength")
90
88
        s.write(tmpf)
91
89
        tmpf.seek(0)
92
90
        self.assertEqual(tmpf.read(), b'''\
110
108
        self.assertTrue('revision' in s)
111
109
        self.assertEqual(s.get('revision'), 'mbp@sourcefrog.net-123-abc')
112
110
        self.assertEqual(list(s.iter_pairs()),
113
 
                         [('revision', 'mbp@sourcefrog.net-123-abc'),
114
 
                          ('timestamp', '1130653962'),
115
 
                          ('timezone', '36000'),
116
 
                          ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
 
111
                [('revision', 'mbp@sourcefrog.net-123-abc'),
 
112
                 ('timestamp', '1130653962'),
 
113
                 ('timezone', '36000'),
 
114
                 ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
117
115
        self.assertEqual(len(s), 4)
118
116
 
119
117
    def test_repeated_field(self):
209
207
        read_iter = iter(reader)
210
208
        stuff = list(reader)
211
209
        self.assertEqual(stuff,
212
 
                         [Stanza(version_header='1'),
213
 
                          Stanza(name="foo", val='123'),
214
 
                             Stanza(name="bar", val='129319'), ])
 
210
                [ Stanza(version_header='1'),
 
211
                  Stanza(name="foo", val='123'),
 
212
                  Stanza(name="bar", val='129319'), ])
215
213
 
216
214
    def test_read_several(self):
217
215
        """Read several stanzas from file"""
295
293
''')
296
294
        tmpf.seek(0)
297
295
        expected_vals = ['"one"',
298
 
                         '\n"one"\n',
299
 
                         '"',
300
 
                         '""',
301
 
                         '"""',
302
 
                         '\n',
303
 
                         '\\',
304
 
                         '\n\\\n\\\\\n',
305
 
                         'word\\',
306
 
                         'quote\"',
307
 
                         'backslashes\\\\\\',
308
 
                         'both\\\"',
309
 
                         ]
 
296
            '\n"one"\n',
 
297
            '"',
 
298
            '""',
 
299
            '"""',
 
300
            '\n',
 
301
            '\\',
 
302
            '\n\\\n\\\\\n',
 
303
            'word\\',
 
304
            'quote\"',
 
305
            'backslashes\\\\\\',
 
306
            'both\\\"',
 
307
            ]
310
308
        for expected in expected_vals:
311
309
            stanza = read_stanza(tmpf)
312
310
            self.rio_file_stanzas([stanza])
328
326
        s = Stanza()
329
327
        self.assertRaises(TypeError, s.add, 10, {})
330
328
 
331
 
    def test_rio_surrogateescape(self):
332
 
        raw_bytes = b'\xcb'
333
 
        self.assertRaises(UnicodeDecodeError, raw_bytes.decode, 'utf-8')
334
 
        try:
335
 
            uni_data = raw_bytes.decode('utf-8', 'surrogateescape')
336
 
        except LookupError:
337
 
            self.skipTest('surrogateescape is not available on Python < 3')
338
 
        s = Stanza(foo=uni_data)
339
 
        self.assertEqual(s.get('foo'), uni_data)
340
 
        raw_lines = s.to_lines()
341
 
        self.assertEqual(raw_lines,
342
 
                         [b'foo: ' + uni_data.encode('utf-8', 'surrogateescape') + b'\n'])
343
 
        new_s = read_stanza(raw_lines)
344
 
        self.assertEqual(new_s.get('foo'), uni_data)
345
 
 
346
329
    def test_rio_unicode(self):
347
330
        uni_data = u'\N{KATAKANA LETTER O}'
348
331
        s = Stanza(foo=uni_data)
349
332
        self.assertEqual(s.get('foo'), uni_data)
350
333
        raw_lines = s.to_lines()
351
334
        self.assertEqual(raw_lines,
352
 
                         [b'foo: ' + uni_data.encode('utf-8') + b'\n'])
 
335
                [b'foo: ' + uni_data.encode('utf-8') + b'\n'])
353
336
        new_s = read_stanza(raw_lines)
354
337
        self.assertEqual(new_s.get('foo'), uni_data)
355
338
 
368
351
        raw_lines = parent_stanza.to_lines()
369
352
        self.assertEqual([b'child: foo: ' + uni_data.encode('utf-8') + b'\n',
370
353
                          b'\t\n',
371
 
                          ], raw_lines)
 
354
                         ], raw_lines)
372
355
        new_parent = read_stanza(raw_lines)
373
356
        child_text = new_parent.get('child')
374
357
        self.assertEqual(u'foo: %s\n' % uni_data, child_text)
397
380
        lines = self.mail_munge(lines)
398
381
        new_stanza = rio.read_patch_stanza(lines)
399
382
        self.assertEqual('#\n\r\\r ', new_stanza.get('data'))
400
 
        self.assertEqual(' ' * 255, new_stanza.get('space'))
401
 
        self.assertEqual('#' * 255, new_stanza.get('hash'))
 
383
        self.assertEqual(' '* 255, new_stanza.get('space'))
 
384
        self.assertEqual('#'* 255, new_stanza.get('hash'))
402
385
 
403
386
    def test_patch_rio_linebreaks(self):
404
 
        stanza = Stanza(breaktest='linebreak -/' * 30)
 
387
        stanza = Stanza(breaktest='linebreak -/'*30)
405
388
        self.assertContainsRe(rio.to_patch_lines(stanza, 71)[0],
406
389
                              b'linebreak\\\\\n')
407
 
        stanza = Stanza(breaktest='linebreak-/' * 30)
 
390
        stanza = Stanza(breaktest='linebreak-/'*30)
408
391
        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],
409
392
                              b'linebreak-\\\\\n')
410
 
        stanza = Stanza(breaktest='linebreak/' * 30)
 
393
        stanza = Stanza(breaktest='linebreak/'*30)
411
394
        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],
412
395
                              b'linebreak\\\\\n')