/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: 2020-03-22 01:35:14 UTC
  • mfrom: (7490.7.6 work)
  • mto: This revision was merged to the branch mainline in revision 7499.
  • Revision ID: jelmer@jelmer.uk-20200322013514-7vw1ntwho04rcuj3
merge lp:brz/3.1.

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\\""', number='42', name='fred')
 
76
        s = Stanza(a_thing='something with "quotes like \\"this\\""',
 
77
                   number='42', name='fred')
77
78
        s.write(tmpf)
78
79
        tmpf.seek(0)
79
80
        self.assertEqual(tmpf.read(), b'''\
84
85
 
85
86
    def test_multiline_string(self):
86
87
        tmpf = TemporaryFile()
87
 
        s = Stanza(motto="war is peace\nfreedom is slavery\nignorance is strength")
 
88
        s = Stanza(
 
89
            motto="war is peace\nfreedom is slavery\nignorance is strength")
88
90
        s.write(tmpf)
89
91
        tmpf.seek(0)
90
92
        self.assertEqual(tmpf.read(), b'''\
108
110
        self.assertTrue('revision' in s)
109
111
        self.assertEqual(s.get('revision'), 'mbp@sourcefrog.net-123-abc')
110
112
        self.assertEqual(list(s.iter_pairs()),
111
 
                [('revision', 'mbp@sourcefrog.net-123-abc'),
112
 
                 ('timestamp', '1130653962'),
113
 
                 ('timezone', '36000'),
114
 
                 ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
 
113
                         [('revision', 'mbp@sourcefrog.net-123-abc'),
 
114
                          ('timestamp', '1130653962'),
 
115
                          ('timezone', '36000'),
 
116
                          ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
115
117
        self.assertEqual(len(s), 4)
116
118
 
117
119
    def test_repeated_field(self):
207
209
        read_iter = iter(reader)
208
210
        stuff = list(reader)
209
211
        self.assertEqual(stuff,
210
 
                [ Stanza(version_header='1'),
211
 
                  Stanza(name="foo", val='123'),
212
 
                  Stanza(name="bar", val='129319'), ])
 
212
                         [Stanza(version_header='1'),
 
213
                          Stanza(name="foo", val='123'),
 
214
                             Stanza(name="bar", val='129319'), ])
213
215
 
214
216
    def test_read_several(self):
215
217
        """Read several stanzas from file"""
293
295
''')
294
296
        tmpf.seek(0)
295
297
        expected_vals = ['"one"',
296
 
            '\n"one"\n',
297
 
            '"',
298
 
            '""',
299
 
            '"""',
300
 
            '\n',
301
 
            '\\',
302
 
            '\n\\\n\\\\\n',
303
 
            'word\\',
304
 
            'quote\"',
305
 
            'backslashes\\\\\\',
306
 
            'both\\\"',
307
 
            ]
 
298
                         '\n"one"\n',
 
299
                         '"',
 
300
                         '""',
 
301
                         '"""',
 
302
                         '\n',
 
303
                         '\\',
 
304
                         '\n\\\n\\\\\n',
 
305
                         'word\\',
 
306
                         'quote\"',
 
307
                         'backslashes\\\\\\',
 
308
                         'both\\\"',
 
309
                         ]
308
310
        for expected in expected_vals:
309
311
            stanza = read_stanza(tmpf)
310
312
            self.rio_file_stanzas([stanza])
332
334
        self.assertEqual(s.get('foo'), uni_data)
333
335
        raw_lines = s.to_lines()
334
336
        self.assertEqual(raw_lines,
335
 
                [b'foo: ' + uni_data.encode('utf-8') + b'\n'])
 
337
                         [b'foo: ' + uni_data.encode('utf-8') + b'\n'])
336
338
        new_s = read_stanza(raw_lines)
337
339
        self.assertEqual(new_s.get('foo'), uni_data)
338
340
 
351
353
        raw_lines = parent_stanza.to_lines()
352
354
        self.assertEqual([b'child: foo: ' + uni_data.encode('utf-8') + b'\n',
353
355
                          b'\t\n',
354
 
                         ], raw_lines)
 
356
                          ], raw_lines)
355
357
        new_parent = read_stanza(raw_lines)
356
358
        child_text = new_parent.get('child')
357
359
        self.assertEqual(u'foo: %s\n' % uni_data, child_text)
380
382
        lines = self.mail_munge(lines)
381
383
        new_stanza = rio.read_patch_stanza(lines)
382
384
        self.assertEqual('#\n\r\\r ', new_stanza.get('data'))
383
 
        self.assertEqual(' '* 255, new_stanza.get('space'))
384
 
        self.assertEqual('#'* 255, new_stanza.get('hash'))
 
385
        self.assertEqual(' ' * 255, new_stanza.get('space'))
 
386
        self.assertEqual('#' * 255, new_stanza.get('hash'))
385
387
 
386
388
    def test_patch_rio_linebreaks(self):
387
 
        stanza = Stanza(breaktest='linebreak -/'*30)
 
389
        stanza = Stanza(breaktest='linebreak -/' * 30)
388
390
        self.assertContainsRe(rio.to_patch_lines(stanza, 71)[0],
389
391
                              b'linebreak\\\\\n')
390
 
        stanza = Stanza(breaktest='linebreak-/'*30)
 
392
        stanza = Stanza(breaktest='linebreak-/' * 30)
391
393
        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],
392
394
                              b'linebreak-\\\\\n')
393
 
        stanza = Stanza(breaktest='linebreak/'*30)
 
395
        stanza = Stanza(breaktest='linebreak/' * 30)
394
396
        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],
395
397
                              b'linebreak\\\\\n')