~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_pack.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-08-09 15:19:06 UTC
  • mfrom: (2681.1.7 send-bundle)
  • Revision ID: pqm@pqm.ubuntu.com-20070809151906-hdn9oyslf2qib2op
Allow omitting -o for bundle, add --format

Show diffs side-by-side

added added

removed removed

Lines of Context:
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for bzrlib.pack."""
18
18
 
22
22
from bzrlib import pack, errors, tests
23
23
 
24
24
 
25
 
class TestContainerSerialiser(tests.TestCase):
26
 
    """Tests for the ContainerSerialiser class."""
27
 
 
28
 
    def test_construct(self):
29
 
        """Test constructing a ContainerSerialiser."""
30
 
        pack.ContainerSerialiser()
31
 
 
32
 
    def test_begin(self):
33
 
        serialiser = pack.ContainerSerialiser()
34
 
        self.assertEqual('Bazaar pack format 1 (introduced in 0.18)\n',
35
 
                         serialiser.begin())
36
 
 
37
 
    def test_end(self):
38
 
        serialiser = pack.ContainerSerialiser()
39
 
        self.assertEqual('E', serialiser.end())
40
 
 
41
 
    def test_bytes_record_no_name(self):
42
 
        serialiser = pack.ContainerSerialiser()
43
 
        record = serialiser.bytes_record('bytes', [])
44
 
        self.assertEqual('B5\n\nbytes', record)
45
 
 
46
 
    def test_bytes_record_one_name_with_one_part(self):
47
 
        serialiser = pack.ContainerSerialiser()
48
 
        record = serialiser.bytes_record('bytes', [('name',)])
49
 
        self.assertEqual('B5\nname\n\nbytes', record)
50
 
 
51
 
    def test_bytes_record_one_name_with_two_parts(self):
52
 
        serialiser = pack.ContainerSerialiser()
53
 
        record = serialiser.bytes_record('bytes', [('part1', 'part2')])
54
 
        self.assertEqual('B5\npart1\x00part2\n\nbytes', record)
55
 
 
56
 
    def test_bytes_record_two_names(self):
57
 
        serialiser = pack.ContainerSerialiser()
58
 
        record = serialiser.bytes_record('bytes', [('name1',), ('name2',)])
59
 
        self.assertEqual('B5\nname1\nname2\n\nbytes', record)
60
 
 
61
 
    def test_bytes_record_whitespace_in_name_part(self):
62
 
        serialiser = pack.ContainerSerialiser()
63
 
        self.assertRaises(
64
 
            errors.InvalidRecordError,
65
 
            serialiser.bytes_record, 'bytes', [('bad name',)])
66
 
 
67
 
 
68
25
class TestContainerWriter(tests.TestCase):
69
26
 
70
 
    def setUp(self):
71
 
        tests.TestCase.setUp(self)
72
 
        self.output = StringIO()
73
 
        self.writer = pack.ContainerWriter(self.output.write)
74
 
 
75
 
    def assertOutput(self, expected_output):
76
 
        """Assert that the output of self.writer ContainerWriter is equal to
77
 
        expected_output.
78
 
        """
79
 
        self.assertEqual(expected_output, self.output.getvalue())
80
 
 
81
27
    def test_construct(self):
82
28
        """Test constructing a ContainerWriter.
83
 
 
84
 
        This uses None as the output stream to show that the constructor
85
 
        doesn't try to use the output stream.
 
29
        
 
30
        This uses None as the output stream to show that the constructor doesn't
 
31
        try to use the output stream.
86
32
        """
87
33
        writer = pack.ContainerWriter(None)
88
34
 
89
35
    def test_begin(self):
90
36
        """The begin() method writes the container format marker line."""
91
 
        self.writer.begin()
92
 
        self.assertOutput('Bazaar pack format 1 (introduced in 0.18)\n')
93
 
 
94
 
    def test_zero_records_written_after_begin(self):
95
 
        """After begin is written, 0 records have been written."""
96
 
        self.writer.begin()
97
 
        self.assertEqual(0, self.writer.records_written)
 
37
        output = StringIO()
 
38
        writer = pack.ContainerWriter(output.write)
 
39
        writer.begin()
 
40
        self.assertEqual('Bazaar pack format 1 (introduced in 0.18)\n',
 
41
                         output.getvalue())
98
42
 
99
43
    def test_end(self):
100
44
        """The end() method writes an End Marker record."""
101
 
        self.writer.begin()
102
 
        self.writer.end()
103
 
        self.assertOutput('Bazaar pack format 1 (introduced in 0.18)\nE')
104
 
 
105
 
    def test_empty_end_does_not_add_a_record_to_records_written(self):
106
 
        """The end() method does not count towards the records written."""
107
 
        self.writer.begin()
108
 
        self.writer.end()
109
 
        self.assertEqual(0, self.writer.records_written)
110
 
 
111
 
    def test_non_empty_end_does_not_add_a_record_to_records_written(self):
112
 
        """The end() method does not count towards the records written."""
113
 
        self.writer.begin()
114
 
        self.writer.add_bytes_record('foo', names=[])
115
 
        self.writer.end()
116
 
        self.assertEqual(1, self.writer.records_written)
 
45
        output = StringIO()
 
46
        writer = pack.ContainerWriter(output.write)
 
47
        writer.begin()
 
48
        writer.end()
 
49
        self.assertEqual('Bazaar pack format 1 (introduced in 0.18)\nE',
 
50
                         output.getvalue())
117
51
 
118
52
    def test_add_bytes_record_no_name(self):
119
53
        """Add a bytes record with no name."""
120
 
        self.writer.begin()
121
 
        offset, length = self.writer.add_bytes_record('abc', names=[])
 
54
        output = StringIO()
 
55
        writer = pack.ContainerWriter(output.write)
 
56
        writer.begin()
 
57
        offset, length = writer.add_bytes_record('abc', names=[])
122
58
        self.assertEqual((42, 7), (offset, length))
123
 
        self.assertOutput(
124
 
            'Bazaar pack format 1 (introduced in 0.18)\nB3\n\nabc')
 
59
        self.assertEqual('Bazaar pack format 1 (introduced in 0.18)\nB3\n\nabc',
 
60
                         output.getvalue())
125
61
 
126
62
    def test_add_bytes_record_one_name(self):
127
63
        """Add a bytes record with one name."""
128
 
        self.writer.begin()
129
 
        offset, length = self.writer.add_bytes_record(
130
 
            'abc', names=[('name1', )])
 
64
        output = StringIO()
 
65
        writer = pack.ContainerWriter(output.write)
 
66
        writer.begin()
 
67
        offset, length = writer.add_bytes_record('abc', names=[('name1', )])
131
68
        self.assertEqual((42, 13), (offset, length))
132
 
        self.assertOutput(
133
 
            'Bazaar pack format 1 (introduced in 0.18)\n'
134
 
            'B3\nname1\n\nabc')
135
 
 
136
 
    def test_add_bytes_record_two_names(self):
137
 
        """Add a bytes record with two names."""
138
 
        self.writer.begin()
139
 
        offset, length = self.writer.add_bytes_record(
140
 
            'abc', names=[('name1', ), ('name2', )])
141
 
        self.assertEqual((42, 19), (offset, length))
142
 
        self.assertOutput(
143
 
            'Bazaar pack format 1 (introduced in 0.18)\n'
144
 
            'B3\nname1\nname2\n\nabc')
145
 
 
146
 
    def test_add_bytes_record_two_names(self):
147
 
        """Add a bytes record with two names."""
148
 
        self.writer.begin()
149
 
        offset, length = self.writer.add_bytes_record(
150
 
            'abc', names=[('name1', ), ('name2', )])
151
 
        self.assertEqual((42, 19), (offset, length))
152
 
        self.assertOutput(
153
 
            'Bazaar pack format 1 (introduced in 0.18)\n'
154
 
            'B3\nname1\nname2\n\nabc')
 
69
        self.assertEqual(
 
70
            'Bazaar pack format 1 (introduced in 0.18)\n'
 
71
            'B3\nname1\n\nabc',
 
72
            output.getvalue())
 
73
 
 
74
    def test_add_bytes_record_two_names(self):
 
75
        """Add a bytes record with two names."""
 
76
        output = StringIO()
 
77
        writer = pack.ContainerWriter(output.write)
 
78
        writer.begin()
 
79
        offset, length = writer.add_bytes_record('abc', names=[('name1', ), ('name2', )])
 
80
        self.assertEqual((42, 19), (offset, length))
 
81
        self.assertEqual(
 
82
            'Bazaar pack format 1 (introduced in 0.18)\n'
 
83
            'B3\nname1\nname2\n\nabc',
 
84
            output.getvalue())
 
85
 
 
86
    def test_add_bytes_record_two_names(self):
 
87
        """Add a bytes record with two names."""
 
88
        output = StringIO()
 
89
        writer = pack.ContainerWriter(output.write)
 
90
        writer.begin()
 
91
        offset, length = writer.add_bytes_record('abc', names=[('name1', ), ('name2', )])
 
92
        self.assertEqual((42, 19), (offset, length))
 
93
        self.assertEqual(
 
94
            'Bazaar pack format 1 (introduced in 0.18)\n'
 
95
            'B3\nname1\nname2\n\nabc',
 
96
            output.getvalue())
155
97
 
156
98
    def test_add_bytes_record_two_element_name(self):
157
99
        """Add a bytes record with a two-element name."""
158
 
        self.writer.begin()
159
 
        offset, length = self.writer.add_bytes_record(
160
 
            'abc', names=[('name1', 'name2')])
 
100
        output = StringIO()
 
101
        writer = pack.ContainerWriter(output.write)
 
102
        writer.begin()
 
103
        offset, length = writer.add_bytes_record('abc', names=[('name1', 'name2')])
161
104
        self.assertEqual((42, 19), (offset, length))
162
 
        self.assertOutput(
 
105
        self.assertEqual(
163
106
            'Bazaar pack format 1 (introduced in 0.18)\n'
164
 
            'B3\nname1\x00name2\n\nabc')
 
107
            'B3\nname1\x00name2\n\nabc',
 
108
            output.getvalue())
165
109
 
166
110
    def test_add_second_bytes_record_gets_higher_offset(self):
167
 
        self.writer.begin()
168
 
        self.writer.add_bytes_record('abc', names=[])
169
 
        offset, length = self.writer.add_bytes_record('abc', names=[])
 
111
        output = StringIO()
 
112
        writer = pack.ContainerWriter(output.write)
 
113
        writer.begin()
 
114
        writer.add_bytes_record('abc', names=[])
 
115
        offset, length = writer.add_bytes_record('abc', names=[])
170
116
        self.assertEqual((49, 7), (offset, length))
171
 
        self.assertOutput(
 
117
        self.assertEqual(
172
118
            'Bazaar pack format 1 (introduced in 0.18)\n'
173
119
            'B3\n\nabc'
174
 
            'B3\n\nabc')
 
120
            'B3\n\nabc',
 
121
            output.getvalue())
175
122
 
176
123
    def test_add_bytes_record_invalid_name(self):
177
124
        """Adding a Bytes record with a name with whitespace in it raises
178
125
        InvalidRecordError.
179
126
        """
180
 
        self.writer.begin()
 
127
        output = StringIO()
 
128
        writer = pack.ContainerWriter(output.write)
 
129
        writer.begin()
181
130
        self.assertRaises(
182
131
            errors.InvalidRecordError,
183
 
            self.writer.add_bytes_record, 'abc', names=[('bad name', )])
184
 
 
185
 
    def test_add_bytes_records_add_to_records_written(self):
186
 
        """Adding a Bytes record increments the records_written counter."""
187
 
        self.writer.begin()
188
 
        self.writer.add_bytes_record('foo', names=[])
189
 
        self.assertEqual(1, self.writer.records_written)
190
 
        self.writer.add_bytes_record('foo', names=[])
191
 
        self.assertEqual(2, self.writer.records_written)
 
132
            writer.add_bytes_record, 'abc', names=[('bad name', )])
192
133
 
193
134
 
194
135
class TestContainerReader(tests.TestCase):
195
 
    """Tests for the ContainerReader.
196
 
 
197
 
    The ContainerReader reads format 1 containers, so these tests explicitly
198
 
    test how it reacts to format 1 data.  If a new version of the format is
199
 
    added, then separate tests for that format should be added.
200
 
    """
201
136
 
202
137
    def get_reader_for(self, bytes):
203
138
        stream = StringIO(bytes)
206
141
 
207
142
    def test_construct(self):
208
143
        """Test constructing a ContainerReader.
209
 
 
 
144
        
210
145
        This uses None as the output stream to show that the constructor doesn't
211
146
        try to use the input stream.
212
147
        """
244
179
 
245
180
    def test_container_with_one_unnamed_record(self):
246
181
        """Read a container with one Bytes record.
247
 
 
 
182
        
248
183
        Parsing Bytes records is more thoroughly exercised by
249
184
        TestBytesRecordReader.  This test is here to ensure that
250
185
        ContainerReader's integration with BytesRecordReader is working.
327
262
        reader = self.get_reader_for(
328
263
            "Bazaar pack format 1 (introduced in 0.18)\nB0\n\xcc\n\nE")
329
264
        self.assertRaises(errors.InvalidRecordError, reader.validate)
330
 
 
 
265
        
331
266
 
332
267
class TestBytesRecordReader(tests.TestCase):
333
 
    """Tests for reading and validating Bytes records with
334
 
    BytesRecordReader.
335
 
 
336
 
    Like TestContainerReader, this explicitly tests the reading of format 1
337
 
    data.  If a new version of the format is added, then a separate set of
338
 
    tests for reading that format should be added.
339
 
    """
 
268
    """Tests for reading and validating Bytes records with BytesRecordReader."""
340
269
 
341
270
    def get_reader_for(self, bytes):
342
271
        stream = StringIO(bytes)
386
315
    def test_early_eof(self):
387
316
        """Tests for premature EOF occuring during parsing Bytes records with
388
317
        BytesRecordReader.
389
 
 
 
318
        
390
319
        A incomplete container might be interrupted at any point.  The
391
320
        BytesRecordReader needs to cope with the input stream running out no
392
321
        matter where it is in the parsing process.
519
448
    """Tests of the ReadVFile class.
520
449
 
521
450
    Error cases are deliberately undefined: this code adapts the underlying
522
 
    transport interface to a single 'streaming read' interface as
 
451
    transport interface to a single 'streaming read' interface as 
523
452
    ContainerReader needs.
524
453
    """
525
454
 
560
489
        results.append(f.readline())
561
490
        results.append(f.read(4))
562
491
        self.assertEqual(['0', '\n', '2\n4\n'], results)
563
 
 
564
 
 
565
 
class PushParserTestCase(tests.TestCase):
566
 
    """Base class for TestCases involving ContainerPushParser."""
567
 
 
568
 
    def make_parser_expecting_record_type(self):
569
 
        parser = pack.ContainerPushParser()
570
 
        parser.accept_bytes("Bazaar pack format 1 (introduced in 0.18)\n")
571
 
        return parser
572
 
 
573
 
    def make_parser_expecting_bytes_record(self):
574
 
        parser = pack.ContainerPushParser()
575
 
        parser.accept_bytes("Bazaar pack format 1 (introduced in 0.18)\nB")
576
 
        return parser
577
 
 
578
 
    def assertRecordParsing(self, expected_record, bytes):
579
 
        """Assert that 'bytes' is parsed as a given bytes record.
580
 
 
581
 
        :param expected_record: A tuple of (names, bytes).
582
 
        """
583
 
        parser = self.make_parser_expecting_bytes_record()
584
 
        parser.accept_bytes(bytes)
585
 
        parsed_records = parser.read_pending_records()
586
 
        self.assertEqual([expected_record], parsed_records)
587
 
 
588
 
 
589
 
class TestContainerPushParser(PushParserTestCase):
590
 
    """Tests for ContainerPushParser.
591
 
 
592
 
    The ContainerPushParser reads format 1 containers, so these tests
593
 
    explicitly test how it reacts to format 1 data.  If a new version of the
594
 
    format is added, then separate tests for that format should be added.
595
 
    """
596
 
 
597
 
    def test_construct(self):
598
 
        """ContainerPushParser can be constructed."""
599
 
        pack.ContainerPushParser()
600
 
 
601
 
    def test_multiple_records_at_once(self):
602
 
        """If multiple records worth of data are fed to the parser in one
603
 
        string, the parser will correctly parse all the records.
604
 
 
605
 
        (A naive implementation might stop after parsing the first record.)
606
 
        """
607
 
        parser = self.make_parser_expecting_record_type()
608
 
        parser.accept_bytes("B5\nname1\n\nbody1B5\nname2\n\nbody2")
609
 
        self.assertEqual(
610
 
            [([('name1',)], 'body1'), ([('name2',)], 'body2')],
611
 
            parser.read_pending_records())
612
 
 
613
 
 
614
 
class TestContainerPushParserBytesParsing(PushParserTestCase):
615
 
    """Tests for reading Bytes records with ContainerPushParser.
616
 
 
617
 
    The ContainerPushParser reads format 1 containers, so these tests
618
 
    explicitly test how it reacts to format 1 data.  If a new version of the
619
 
    format is added, then separate tests for that format should be added.
620
 
    """
621
 
 
622
 
    def test_record_with_no_name(self):
623
 
        """Reading a Bytes record with no name returns an empty list of
624
 
        names.
625
 
        """
626
 
        self.assertRecordParsing(([], 'aaaaa'), "5\n\naaaaa")
627
 
 
628
 
    def test_record_with_one_name(self):
629
 
        """Reading a Bytes record with one name returns a list of just that
630
 
        name.
631
 
        """
632
 
        self.assertRecordParsing(
633
 
            ([('name1', )], 'aaaaa'),
634
 
            "5\nname1\n\naaaaa")
635
 
 
636
 
    def test_record_with_two_names(self):
637
 
        """Reading a Bytes record with two names returns a list of both names.
638
 
        """
639
 
        self.assertRecordParsing(
640
 
            ([('name1', ), ('name2', )], 'aaaaa'),
641
 
            "5\nname1\nname2\n\naaaaa")
642
 
 
643
 
    def test_record_with_two_part_names(self):
644
 
        """Reading a Bytes record with a two_part name reads both."""
645
 
        self.assertRecordParsing(
646
 
            ([('name1', 'name2')], 'aaaaa'),
647
 
            "5\nname1\x00name2\n\naaaaa")
648
 
 
649
 
    def test_invalid_length(self):
650
 
        """If the length-prefix is not a number, parsing raises
651
 
        InvalidRecordError.
652
 
        """
653
 
        parser = self.make_parser_expecting_bytes_record()
654
 
        self.assertRaises(
655
 
            errors.InvalidRecordError, parser.accept_bytes, "not a number\n")
656
 
 
657
 
    def test_incomplete_record(self):
658
 
        """If the bytes seen so far don't form a complete record, then there
659
 
        will be nothing returned by read_pending_records.
660
 
        """
661
 
        parser = self.make_parser_expecting_bytes_record()
662
 
        parser.accept_bytes("5\n\nabcd")
663
 
        self.assertEqual([], parser.read_pending_records())
664
 
 
665
 
    def test_accept_nothing(self):
666
 
        """The edge case of parsing an empty string causes no error."""
667
 
        parser = self.make_parser_expecting_bytes_record()
668
 
        parser.accept_bytes("")
669
 
 
670
 
    def assertInvalidRecord(self, bytes):
671
 
        """Assert that parsing the given bytes will raise an
672
 
        InvalidRecordError.
673
 
        """
674
 
        parser = self.make_parser_expecting_bytes_record()
675
 
        self.assertRaises(
676
 
            errors.InvalidRecordError, parser.accept_bytes, bytes)
677
 
 
678
 
    def test_read_invalid_name_whitespace(self):
679
 
        """Names must have no whitespace."""
680
 
        # A name with a space.
681
 
        self.assertInvalidRecord("0\nbad name\n\n")
682
 
 
683
 
        # A name with a tab.
684
 
        self.assertInvalidRecord("0\nbad\tname\n\n")
685
 
 
686
 
        # A name with a vertical tab.
687
 
        self.assertInvalidRecord("0\nbad\vname\n\n")
688
 
 
689
 
    def test_repeated_read_pending_records(self):
690
 
        """read_pending_records will not return the same record twice."""
691
 
        parser = self.make_parser_expecting_bytes_record()
692
 
        parser.accept_bytes("6\n\nabcdef")
693
 
        self.assertEqual([([], 'abcdef')], parser.read_pending_records())
694
 
        self.assertEqual([], parser.read_pending_records())
695
 
 
696