/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_smart_transport.py

Remove 'excess_buffer' attribute and another crufty comment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_transport.py
607
607
        self.accepted_bytes = ''
608
608
        self._finished_reading = False
609
609
        self.expected_bytes = expected_bytes
610
 
        self.excess_buffer = ''
 
610
        self.unused_data = ''
611
611
 
612
612
    def accept_bytes(self, bytes):
613
613
        self.accepted_bytes += bytes
614
614
        if self.accepted_bytes.startswith(self.expected_bytes):
615
615
            self._finished_reading = True
616
 
            self.excess_buffer = self.accepted_bytes[len(self.expected_bytes):]
 
616
            self.unused_data = self.accepted_bytes[len(self.expected_bytes):]
617
617
 
618
618
    def next_read_size(self):
619
619
        if self._finished_reading:
1530
1530
 
1531
1531
    def test_construct_version_one_server_protocol(self):
1532
1532
        smart_protocol = protocol.SmartServerRequestProtocolOne(None, None)
1533
 
        self.assertEqual('', smart_protocol.excess_buffer)
 
1533
        self.assertEqual('', smart_protocol.unused_data)
1534
1534
        self.assertEqual('', smart_protocol.in_buffer)
1535
1535
        self.assertFalse(smart_protocol.has_dispatched)
1536
1536
        self.assertEqual(1, smart_protocol.next_read_size())
1575
1575
        smart_protocol.accept_bytes('readv\x01foo\n3\n3,3done\n')
1576
1576
        self.assertEqual(0, smart_protocol.next_read_size())
1577
1577
        self.assertEqual('readv\n3\ndefdone\n', out_stream.getvalue())
1578
 
        self.assertEqual('', smart_protocol.excess_buffer)
 
1578
        self.assertEqual('', smart_protocol.unused_data)
1579
1579
        self.assertEqual('', smart_protocol.in_buffer)
1580
1580
 
1581
1581
    def test_accept_excess_bytes_are_preserved(self):
1584
1584
            None, out_stream.write)
1585
1585
        smart_protocol.accept_bytes('hello\nhello\n')
1586
1586
        self.assertEqual("ok\x013\n", out_stream.getvalue())
1587
 
        self.assertEqual("hello\n", smart_protocol.excess_buffer)
 
1587
        self.assertEqual("hello\n", smart_protocol.unused_data)
1588
1588
        self.assertEqual("", smart_protocol.in_buffer)
1589
1589
 
1590
1590
    def test_accept_excess_bytes_after_body(self):
1591
1591
        protocol = self.build_protocol_waiting_for_body()
1592
1592
        protocol.accept_bytes('7\nabcdefgdone\nX')
1593
1593
        self.assertTrue(self.end_received)
1594
 
        self.assertEqual("X", protocol.excess_buffer)
 
1594
        self.assertEqual("X", protocol.unused_data)
1595
1595
        self.assertEqual("", protocol.in_buffer)
1596
1596
        protocol.accept_bytes('Y')
1597
 
        self.assertEqual("XY", protocol.excess_buffer)
 
1597
        self.assertEqual("XY", protocol.unused_data)
1598
1598
        self.assertEqual("", protocol.in_buffer)
1599
1599
 
1600
1600
    def test_accept_excess_bytes_after_dispatch(self):
1604
1604
        smart_protocol.accept_bytes('hello\n')
1605
1605
        self.assertEqual("ok\x013\n", out_stream.getvalue())
1606
1606
        smart_protocol.accept_bytes('hel')
1607
 
        self.assertEqual("hel", smart_protocol.excess_buffer)
 
1607
        self.assertEqual("hel", smart_protocol.unused_data)
1608
1608
        smart_protocol.accept_bytes('lo\n')
1609
 
        self.assertEqual("hello\n", smart_protocol.excess_buffer)
 
1609
        self.assertEqual("hello\n", smart_protocol.unused_data)
1610
1610
        self.assertEqual("", smart_protocol.in_buffer)
1611
1611
 
1612
1612
    def test__send_response_sets_finished_reading(self):
1775
1775
 
1776
1776
    def test_construct_version_two_server_protocol(self):
1777
1777
        smart_protocol = protocol.SmartServerRequestProtocolTwo(None, None)
1778
 
        self.assertEqual('', smart_protocol.excess_buffer)
 
1778
        self.assertEqual('', smart_protocol.unused_data)
1779
1779
        self.assertEqual('', smart_protocol.in_buffer)
1780
1780
        self.assertFalse(smart_protocol.has_dispatched)
1781
1781
        self.assertEqual(1, smart_protocol.next_read_size())
1822
1822
        self.assertEqual(self.response_marker +
1823
1823
                         'success\nreadv\n3\ndefdone\n',
1824
1824
                         out_stream.getvalue())
1825
 
        self.assertEqual('', smart_protocol.excess_buffer)
 
1825
        self.assertEqual('', smart_protocol.unused_data)
1826
1826
        self.assertEqual('', smart_protocol.in_buffer)
1827
1827
 
1828
1828
    def test_accept_excess_bytes_are_preserved(self):
1831
1831
        smart_protocol.accept_bytes('hello\nhello\n')
1832
1832
        self.assertEqual(self.response_marker + "success\nok\x013\n",
1833
1833
                         out_stream.getvalue())
1834
 
        self.assertEqual("hello\n", smart_protocol.excess_buffer)
 
1834
        self.assertEqual("hello\n", smart_protocol.unused_data)
1835
1835
        self.assertEqual("", smart_protocol.in_buffer)
1836
1836
 
1837
1837
    def test_accept_excess_bytes_after_body(self):
1840
1840
        server_protocol.accept_bytes('7\nabcdefgdone\n' + self.response_marker)
1841
1841
        self.assertTrue(self.end_received)
1842
1842
        self.assertEqual(self.response_marker,
1843
 
                         server_protocol.excess_buffer)
 
1843
                         server_protocol.unused_data)
1844
1844
        self.assertEqual("", server_protocol.in_buffer)
1845
1845
        server_protocol.accept_bytes('Y')
1846
1846
        self.assertEqual(self.response_marker + "Y",
1847
 
                         server_protocol.excess_buffer)
 
1847
                         server_protocol.unused_data)
1848
1848
        self.assertEqual("", server_protocol.in_buffer)
1849
1849
 
1850
1850
    def test_accept_excess_bytes_after_dispatch(self):
1855
1855
                         out_stream.getvalue())
1856
1856
        smart_protocol.accept_bytes(self.request_marker + 'hel')
1857
1857
        self.assertEqual(self.request_marker + "hel",
1858
 
                         smart_protocol.excess_buffer)
 
1858
                         smart_protocol.unused_data)
1859
1859
        smart_protocol.accept_bytes('lo\n')
1860
1860
        self.assertEqual(self.request_marker + "hello\n",
1861
 
                         smart_protocol.excess_buffer)
 
1861
                         smart_protocol.unused_data)
1862
1862
        self.assertEqual("", smart_protocol.in_buffer)
1863
1863
 
1864
1864
    def test__send_response_sets_finished_reading(self):
2151
2151
 
2152
2152
    def test_construct_version_three_server_protocol(self):
2153
2153
        smart_protocol = protocol.ProtocolThreeDecoder(None)
2154
 
        self.assertEqual('', smart_protocol.excess_buffer)
 
2154
        self.assertEqual('', smart_protocol.unused_data)
2155
2155
        self.assertEqual('', smart_protocol._in_buffer)
2156
2156
        self.assertFalse(smart_protocol.has_dispatched)
2157
2157
        # The protocol starts by expecting four bytes, a length prefix for the
2212
2212
        smart_protocol = self.server_protocol_class(LoggingMessageHandler())
2213
2213
        smart_protocol.accept_bytes(request_bytes)
2214
2214
        self.assertEqual(0, smart_protocol.next_read_size())
2215
 
        self.assertEqual('', smart_protocol.excess_buffer)
 
2215
        self.assertEqual('', smart_protocol.unused_data)
2216
2216
 
2217
2217
    # XXX: TestMessagePartDecoding vvv XXX
2218
2218
    def make_protocol_expecting_message_part(self):
2428
2428
#        smart_protocol = self.client_protocol_class(None)
2429
2429
#        smart_protocol.accept_bytes(request_bytes)
2430
2430
#        self.assertEqual(0, smart_protocol.next_read_size())
2431
 
#        self.assertEqual('', smart_protocol.excess_buffer)
2432
2431
#        self.assertEqual('', smart_protocol.unused_data)
2433
2432
 
2434
2433