← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_groupcompress.py

Do a lot of renaming.

Change the config from 'max_entries_per_source' to 'max_bytes_to_index'.
I'm not 100% happy, because it is max_bytes_to_delta_index_per_source, but
that is just getting rediculously long.
Internally, change the code to take a 'settings' function, which currently
returns a tuple. I'm thinking to change it to a dict.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_groupcompress.py
553
553
                    'as-requested', False)]
554
554
        self.assertEqual([('b',), ('a',), ('d',), ('c',)], keys)
555
555
 
556
 
    def test_get_record_stream_max_entries_per_source_default(self):
 
556
    def test_get_record_stream_max_bytes_to_index_default(self):
557
557
        vf = self.make_test_vf(True, dir='source')
558
558
        vf.add_lines(('a',), (), ['lines\n'])
559
559
        vf.writer.end()
560
560
        record = vf.get_record_stream([('a',)], 'unordered', True).next()
561
 
        self.assertEqual(vf._DEFAULT_MAX_ENTRIES_PER_SOURCE,
562
 
                         record._manager._get_max_entries_per_source())
 
561
        self.assertEqual(vf._DEFAULT_COMPRESSOR_SETTINGS,
 
562
                         record._manager._get_compressor_settings())
563
563
 
564
 
    def test_get_record_stream_accesses_max_entries_per_source_default(self):
 
564
    def test_get_record_stream_accesses_compressor_settings(self):
565
565
        vf = self.make_test_vf(True, dir='source')
566
566
        vf.add_lines(('a',), (), ['lines\n'])
567
567
        vf.writer.end()
568
 
        vf._max_entries_per_source = 1234
 
568
        vf._max_bytes_to_index = 1234
569
569
        record = vf.get_record_stream([('a',)], 'unordered', True).next()
570
 
        self.assertEqual(1234, record._manager._get_max_entries_per_source())
 
570
        self.assertEqual((1234,), record._manager._get_compressor_settings())
571
571
 
572
572
    def test_insert_record_stream_reuses_blocks(self):
573
573
        vf = self.make_test_vf(True, dir='source')
798
798
        self.addCleanup(groupcompress.cleanup_pack_group, vf)
799
799
        return vf
800
800
 
801
 
    def test_max_entries_per_source_default(self):
802
 
        vf = self.make_test_vf()
803
 
        gc = vf._make_group_compressor()
804
 
        self.assertEqual(vf._DEFAULT_MAX_ENTRIES_PER_SOURCE,
805
 
                         vf._max_entries_per_source)
806
 
        if isinstance(gc, groupcompress.PyrexGroupCompressor):
807
 
            self.assertEqual(vf._DEFAULT_MAX_ENTRIES_PER_SOURCE,
808
 
                             gc._delta_index._max_entries_per_source)
809
 
 
810
 
    def test_max_entries_per_source_in_config(self):
811
 
        c = config.GlobalConfig()
812
 
        c.set_user_option('bzr.groupcompress.max_entries_per_source', '10000')
813
 
        vf = self.make_test_vf()
814
 
        gc = vf._make_group_compressor()
815
 
        self.assertEqual(10000, vf._max_entries_per_source)
816
 
        if isinstance(gc, groupcompress.PyrexGroupCompressor):
817
 
            self.assertEqual(10000, gc._delta_index._max_entries_per_source)
818
 
 
819
 
    def test_max_entries_per_source_bad_config(self):
820
 
        c = config.GlobalConfig()
821
 
        c.set_user_option('bzr.groupcompress.max_entries_per_source', 'boogah')
 
801
    def test_max_bytes_to_index_default(self):
 
802
        vf = self.make_test_vf()
 
803
        gc = vf._make_group_compressor()
 
804
        self.assertEqual(vf._DEFAULT_MAX_BYTES_TO_INDEX,
 
805
                         vf._max_bytes_to_index)
 
806
        if isinstance(gc, groupcompress.PyrexGroupCompressor):
 
807
            self.assertEqual(vf._DEFAULT_MAX_BYTES_TO_INDEX,
 
808
                             gc._delta_index._max_bytes_to_index)
 
809
 
 
810
    def test_max_bytes_to_index_in_config(self):
 
811
        c = config.GlobalConfig()
 
812
        c.set_user_option('bzr.groupcompress.max_bytes_to_index', '10000')
 
813
        vf = self.make_test_vf()
 
814
        gc = vf._make_group_compressor()
 
815
        self.assertEqual(10000, vf._max_bytes_to_index)
 
816
        if isinstance(gc, groupcompress.PyrexGroupCompressor):
 
817
            self.assertEqual(10000, gc._delta_index._max_bytes_to_index)
 
818
 
 
819
    def test_max_bytes_to_index_bad_config(self):
 
820
        c = config.GlobalConfig()
 
821
        c.set_user_option('bzr.groupcompress.max_bytes_to_index', 'boogah')
822
822
        vf = self.make_test_vf()
823
823
        # TODO: This is triggering a warning, we might want to trap and make
824
824
        #       sure it is readable.
825
825
        gc = vf._make_group_compressor()
826
 
        self.assertEqual(vf._DEFAULT_MAX_ENTRIES_PER_SOURCE,
827
 
                         vf._max_entries_per_source)
 
826
        self.assertEqual(vf._DEFAULT_MAX_BYTES_TO_INDEX,
 
827
                         vf._max_bytes_to_index)
828
828
        if isinstance(gc, groupcompress.PyrexGroupCompressor):
829
 
            self.assertEqual(vf._DEFAULT_MAX_ENTRIES_PER_SOURCE,
830
 
                             gc._delta_index._max_entries_per_source)
 
829
            self.assertEqual(vf._DEFAULT_MAX_BYTES_TO_INDEX,
 
830
                             gc._delta_index._max_bytes_to_index)
831
831
 
832
832
 
833
833
class StubGCVF(object):
1105
1105
            self.assertEqual(self._texts[record.key],
1106
1106
                             record.get_bytes_as('fulltext'))
1107
1107
 
1108
 
    def test_manager_default_max_entries_per_source(self):
 
1108
    def test_manager_default_compressor_settings(self):
1109
1109
        locations, old_block = self.make_block(self._texts)
1110
1110
        manager = groupcompress._LazyGroupContentManager(old_block)
1111
1111
        gcvf = groupcompress.GroupCompressVersionedFiles
1112
 
        # It doesn't greedily evaluate _max_entries_per_source
1113
 
        self.assertIs(None, manager._max_entries_per_source)
1114
 
        self.assertEqual(gcvf._DEFAULT_MAX_ENTRIES_PER_SOURCE,
1115
 
                         manager._get_max_entries_per_source())
 
1112
        # It doesn't greedily evaluate _max_bytes_to_index
 
1113
        self.assertIs(None, manager._compressor_settings)
 
1114
        self.assertEqual(gcvf._DEFAULT_COMPRESSOR_SETTINGS,
 
1115
                         manager._get_compressor_settings())
1116
1116
 
1117
 
    def test_manager_custom_max_entries_per_source(self):
 
1117
    def test_manager_custom_compressor_settings(self):
1118
1118
        locations, old_block = self.make_block(self._texts)
1119
1119
        called = []
1120
 
        def max_entries():
 
1120
        def compressor_settings():
1121
1121
            called.append('called')
1122
 
            return 10
 
1122
            return (10,)
1123
1123
        manager = groupcompress._LazyGroupContentManager(old_block,
1124
 
            get_max_entries_per_source=max_entries)
 
1124
            get_compressor_settings=compressor_settings)
1125
1125
        gcvf = groupcompress.GroupCompressVersionedFiles
1126
 
        # It doesn't greedily evaluate _max_entries_per_source
1127
 
        self.assertIs(None, manager._max_entries_per_source)
1128
 
        self.assertEqual(10, manager._get_max_entries_per_source())
1129
 
        self.assertEqual(10, manager._get_max_entries_per_source())
1130
 
        self.assertEqual(10, manager._max_entries_per_source)
 
1126
        # It doesn't greedily evaluate compressor_settings
 
1127
        self.assertIs(None, manager._compressor_settings)
 
1128
        self.assertEqual((10,), manager._get_compressor_settings())
 
1129
        self.assertEqual((10,), manager._get_compressor_settings())
 
1130
        self.assertEqual((10,), manager._compressor_settings)
1131
1131
        # Only called 1 time
1132
1132
        self.assertEqual(['called'], called)
1133
1133
 
1134
 
    def test__rebuild_handles_max_entries_per_source(self):
 
1134
    def test__rebuild_handles_compressor_settings(self):
 
1135
        if not isinstance(groupcompress.GroupCompressor,
 
1136
                          groupcompress.PyrexGroupCompressor):
 
1137
            raise tests.TestNotApplicable('pure-python compressor'
 
1138
                ' does not handle compressor_settings')
1135
1139
        locations, old_block = self.make_block(self._texts)
1136
1140
        manager = groupcompress._LazyGroupContentManager(old_block,
1137
 
            get_max_entries_per_source=lambda: 2)
 
1141
            get_compressor_settings=lambda: (32,))
1138
1142
        gc = manager._make_group_compressor()
1139
 
        if isinstance(gc, groupcompress.PyrexGroupCompressor):
1140
 
            self.assertEqual(2, gc._delta_index._max_entries_per_source)
 
1143
        self.assertEqual(32, gc._delta_index._max_bytes_to_index)
1141
1144
        self.add_key_to_manager(('key3',), locations, old_block, manager)
1142
1145
        self.add_key_to_manager(('key4',), locations, old_block, manager)
1143
1146
        action, last_byte, total_bytes = manager._check_rebuild_action()
1145
1148
        manager._rebuild_block()
1146
1149
        new_block = manager._block
1147
1150
        self.assertIsNot(old_block, new_block)
1148
 
        # Because of the new max_entries_per_source, we do a poor job of
 
1151
        # Because of the new max_bytes_to_index, we do a poor job of
1149
1152
        # rebuilding. This is a side-effect of the change, but at least it does
1150
1153
        # show the setting had an effect.
1151
1154
        self.assertTrue(old_block._content_length < new_block._content_length)