← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/interrepository_implementations/__init__.py

  • Committer: Mark Hammond
  • Date: 2008-09-04 12:03:01 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: mhammond@skippinet.com.au-20080904120301-x3tujl7hloy0o75j
build the list of icons without changing directory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/interrepository_implementations/__init__.py
1
 
# Copyright (C) 2006-2011, 2016 Canonical Ltd
 
1
# Copyright (C) 2006 Canonical Ltd
2
2
# Authors: Robert Collins <robert.collins@canonical.com>
3
3
# -*- coding: utf-8 -*-
4
4
#
14
14
#
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
19
 
20
20
"""InterRepository implementation tests for bzr.
21
21
 
22
22
These test the conformance of all the interrepository variations to the
23
23
expected API including generally applicable corner cases.
24
 
Specific tests for individual formats are in the tests/test_repository.py file
25
 
rather than in tests/per_interrepository/*.py.
 
24
Specific tests for individual formats are in the tests/test_repository.py file 
 
25
rather than in tests/interrepository_implementations/*.py.
26
26
"""
27
27
 
28
28
 
29
 
from bzrlib import (
30
 
    pyutils,
31
 
    transport,
32
 
    )
33
29
from bzrlib.errors import (
34
30
    FileExists,
35
31
    UninitializableFormat,
36
32
    )
37
33
 
38
34
from bzrlib.repository import (
39
 
    format_registry,
40
 
    InterRepository,
41
 
    )
 
35
                               InterKnitRepo,
 
36
                               InterKnit1and2,
 
37
                               InterModel1and2,
 
38
                               InterRepository,
 
39
                               )
42
40
from bzrlib.tests import (
43
 
    TestSkipped,
44
 
    default_transport,
45
 
    multiply_tests,
46
 
    )
47
 
from bzrlib.tests.per_controldir.test_controldir import TestCaseWithControlDir
48
 
from bzrlib.vf_repository import (
49
 
    InterDifferingSerializer,
50
 
    )
51
 
 
52
 
 
53
 
def make_scenarios(transport_server, transport_readonly_server, formats):
54
 
    """Transform the input formats to a list of scenarios.
55
 
 
56
 
    :param formats: A list of tuples:
57
 
        (label, repository_format, repository_format_to).
 
41
                          adapt_modules,
 
42
                          default_transport,
 
43
                          TestScenarioApplier,
 
44
                          )
 
45
from bzrlib.tests.bzrdir_implementations.test_bzrdir import TestCaseWithBzrDir
 
46
from bzrlib.transport import get_transport
 
47
 
 
48
 
 
49
class InterRepositoryTestProviderAdapter(TestScenarioApplier):
 
50
    """A tool to generate a suite testing multiple inter repository formats.
 
51
 
 
52
    This is done by copying the test once for each interrepo provider and injecting
 
53
    the transport_server, transport_readonly_server, repository_format and 
 
54
    repository_to_format classes into each copy.
 
55
    Each copy is also given a new id() to make it easy to identify.
58
56
    """
59
 
    result = []
60
 
    for label, repository_format, repository_format_to, extra_setup in formats:
61
 
        id = '%s,%s,%s' % (label, repository_format.__class__.__name__,
62
 
                           repository_format_to.__class__.__name__)
63
 
        scenario = (id,
64
 
            {"transport_server": transport_server,
65
 
             "transport_readonly_server": transport_readonly_server,
66
 
             "repository_format": repository_format,
67
 
             "repository_format_to": repository_format_to,
68
 
             "extra_setup": extra_setup,
69
 
             })
70
 
        result.append(scenario)
71
 
    return result
72
 
 
73
 
 
74
 
def default_test_list():
75
 
    """Generate the default list of interrepo permutations to test."""
76
 
    from bzrlib.repofmt import (
77
 
        groupcompress_repo,
78
 
        knitrepo,
79
 
        knitpack_repo,
80
 
        )
81
 
    result = []
82
 
    def add_combo(interrepo_cls, from_format, to_format, extra_setup=None,
83
 
                  label=None):
84
 
        if label is None:
85
 
            label = interrepo_cls.__name__
86
 
        result.append((label, from_format, to_format, extra_setup))
87
 
    # test the default InterRepository between format 6 and the current
88
 
    # default format.
89
 
    # XXX: robertc 20060220 reinstate this when there are two supported
90
 
    # formats which do not have an optimal code path between them.
91
 
    #result.append((InterRepository,
92
 
    #               RepositoryFormat6(),
93
 
    #               RepositoryFormatKnit1()))
94
 
    for optimiser_class in InterRepository._optimisers:
95
 
        format_to_test = optimiser_class._get_repo_format_to_test()
96
 
        if format_to_test is not None:
97
 
            add_combo(optimiser_class, format_to_test, format_to_test)
98
 
    # if there are specific combinations we want to use, we can add them
99
 
    # here. We want to test rich root upgrading.
100
 
    # XXX: although we attach InterRepository class names to these scenarios,
101
 
    # there's nothing asserting that these labels correspond to what is
102
 
    # actually used.
103
 
    def force_known_graph(testcase):
104
 
        from bzrlib.fetch import Inter1and2Helper
105
 
        testcase.overrideAttr(Inter1and2Helper, 'known_graph_threshold', -1)
106
 
    # Gather extra scenarios from the repository implementations,
107
 
    # as InterRepositories can be used by Repository implementations
108
 
    # they aren't aware of.
109
 
    for module_name in format_registry._get_all_modules():
110
 
        module = pyutils.get_named_object(module_name)
111
 
        try:
112
 
            get_extra_interrepo_test_combinations = getattr(
113
 
                module,
114
 
                "get_extra_interrepo_test_combinations")
115
 
        except AttributeError:
116
 
            continue
117
 
        for (interrepo_cls, from_format, to_format) in (
118
 
            get_extra_interrepo_test_combinations()):
119
 
            add_combo(interrepo_cls, from_format, to_format)
120
 
    add_combo(InterRepository,
121
 
              knitrepo.RepositoryFormatKnit1(),
122
 
              knitrepo.RepositoryFormatKnit3())
123
 
    add_combo(knitrepo.InterKnitRepo,
124
 
              knitrepo.RepositoryFormatKnit1(),
125
 
              knitpack_repo.RepositoryFormatKnitPack1())
126
 
    add_combo(knitrepo.InterKnitRepo,
127
 
              knitpack_repo.RepositoryFormatKnitPack1(),
128
 
              knitrepo.RepositoryFormatKnit1())
129
 
    add_combo(knitrepo.InterKnitRepo,
130
 
              knitrepo.RepositoryFormatKnit3(),
131
 
              knitpack_repo.RepositoryFormatKnitPack3())
132
 
    add_combo(knitrepo.InterKnitRepo,
133
 
              knitpack_repo.RepositoryFormatKnitPack3(),
134
 
              knitrepo.RepositoryFormatKnit3())
135
 
    add_combo(knitrepo.InterKnitRepo,
136
 
              knitpack_repo.RepositoryFormatKnitPack3(),
137
 
              knitpack_repo.RepositoryFormatKnitPack4())
138
 
    add_combo(InterDifferingSerializer,
139
 
              knitpack_repo.RepositoryFormatKnitPack1(),
140
 
              knitpack_repo.RepositoryFormatKnitPack6RichRoot())
141
 
    add_combo(InterDifferingSerializer,
142
 
              knitpack_repo.RepositoryFormatKnitPack1(),
143
 
              knitpack_repo.RepositoryFormatKnitPack6RichRoot(),
144
 
              force_known_graph,
145
 
              label='InterDifferingSerializer+get_known_graph_ancestry')
146
 
    add_combo(InterDifferingSerializer,
147
 
              knitpack_repo.RepositoryFormatKnitPack6RichRoot(),
148
 
              groupcompress_repo.RepositoryFormat2a())
149
 
    add_combo(InterDifferingSerializer,
150
 
              groupcompress_repo.RepositoryFormat2a(),
151
 
              knitpack_repo.RepositoryFormatKnitPack6RichRoot())
152
 
    return result
153
 
 
154
 
 
155
 
class TestCaseWithInterRepository(TestCaseWithControlDir):
 
57
 
 
58
    def __init__(self, transport_server, transport_readonly_server, formats):
 
59
        TestScenarioApplier.__init__(self)
 
60
        self._transport_server = transport_server
 
61
        self._transport_readonly_server = transport_readonly_server
 
62
        self.scenarios = self.formats_to_scenarios(formats)
 
63
    
 
64
    def formats_to_scenarios(self, formats):
 
65
        """Transform the input formats to a list of scenarios.
 
66
 
 
67
        :param formats: A list of tuples:
 
68
            (interrepo_class, repository_format, repository_format_to).
 
69
        """
 
70
        result = []
 
71
        for interrepo_class, repository_format, repository_format_to in formats:
 
72
            id = '%s,%s,%s' % (interrepo_class.__name__,
 
73
                                repository_format.__class__.__name__,
 
74
                                repository_format_to.__class__.__name__)
 
75
            scenario = (id,
 
76
                {"transport_server":self._transport_server,
 
77
                 "transport_readonly_server":self._transport_readonly_server,
 
78
                 "repository_format":repository_format,
 
79
                 "interrepo_class":interrepo_class,
 
80
                 "repository_format_to":repository_format_to,
 
81
                 })
 
82
            result.append(scenario)
 
83
        return result
 
84
    
 
85
    @staticmethod
 
86
    def default_test_list():
 
87
        """Generate the default list of interrepo permutations to test."""
 
88
        from bzrlib.repofmt import knitrepo, pack_repo, weaverepo
 
89
        result = []
 
90
        # test the default InterRepository between format 6 and the current 
 
91
        # default format.
 
92
        # XXX: robertc 20060220 reinstate this when there are two supported
 
93
        # formats which do not have an optimal code path between them.
 
94
        #result.append((InterRepository,
 
95
        #               RepositoryFormat6(),
 
96
        #               RepositoryFormatKnit1()))
 
97
        for optimiser_class in InterRepository._optimisers:
 
98
            format_to_test = optimiser_class._get_repo_format_to_test()
 
99
            if format_to_test is not None:
 
100
                result.append((optimiser_class,
 
101
                               format_to_test, format_to_test))
 
102
        # if there are specific combinations we want to use, we can add them 
 
103
        # here.
 
104
        result.append((InterModel1and2,
 
105
                       weaverepo.RepositoryFormat5(),
 
106
                       knitrepo.RepositoryFormatKnit3()))
 
107
        result.append((InterModel1and2,
 
108
                       knitrepo.RepositoryFormatKnit1(),
 
109
                       knitrepo.RepositoryFormatKnit3()))
 
110
        result.append((InterKnit1and2,
 
111
                       knitrepo.RepositoryFormatKnit1(),
 
112
                       knitrepo.RepositoryFormatKnit3()))
 
113
        result.append((InterKnitRepo,
 
114
                       knitrepo.RepositoryFormatKnit1(),
 
115
                       pack_repo.RepositoryFormatKnitPack1()))
 
116
        result.append((InterKnitRepo,
 
117
                       pack_repo.RepositoryFormatKnitPack1(),
 
118
                       knitrepo.RepositoryFormatKnit1()))
 
119
        result.append((InterKnitRepo,
 
120
                       knitrepo.RepositoryFormatKnit3(),
 
121
                       pack_repo.RepositoryFormatKnitPack3()))
 
122
        result.append((InterKnitRepo,
 
123
                       pack_repo.RepositoryFormatKnitPack3(),
 
124
                       knitrepo.RepositoryFormatKnit3()))
 
125
        return result
 
126
 
 
127
 
 
128
class TestCaseWithInterRepository(TestCaseWithBzrDir):
156
129
 
157
130
    def setUp(self):
158
131
        super(TestCaseWithInterRepository, self).setUp()
159
 
        if self.extra_setup:
160
 
            self.extra_setup(self)
161
 
 
162
 
    def get_default_format(self):
163
 
        self.assertEqual(
164
 
            self.repository_format._matchingbzrdir.repository_format,
165
 
            self.repository_format)
166
 
        return self.repository_format._matchingbzrdir
167
132
 
168
133
    def make_branch(self, relpath, format=None):
169
134
        repo = self.make_repository(relpath, format=format)
175
140
            segments = url.split('/')
176
141
            if segments and segments[-1] not in ('', '.'):
177
142
                parent = '/'.join(segments[:-1])
178
 
                t = transport.get_transport(parent)
 
143
                t = get_transport(parent)
179
144
                try:
180
145
                    t.mkdir(segments[-1])
181
146
                except FileExists:
196
161
        return self.repository_format_to.initialize(made_control)
197
162
 
198
163
 
199
 
def load_tests(standard_tests, module, loader):
200
 
    submod_tests = loader.loadTestsFromModuleNames([
201
 
        'bzrlib.tests.per_interrepository.test_fetch',
202
 
        'bzrlib.tests.per_interrepository.test_interrepository',
203
 
        ])
204
 
    scenarios = make_scenarios(
 
164
def load_tests(basic_tests, module, loader):
 
165
    result = loader.suiteClass()
 
166
    # add the tests for this module
 
167
    result.addTests(basic_tests)
 
168
 
 
169
    test_interrepository_implementations = [
 
170
        'bzrlib.tests.interrepository_implementations.test_fetch',
 
171
        'bzrlib.tests.interrepository_implementations.test_interrepository',
 
172
        ]
 
173
    adapter = InterRepositoryTestProviderAdapter(
205
174
        default_transport,
206
175
        # None here will cause a readonly decorator to be created
207
176
        # by the TestCaseWithTransport.get_readonly_transport method.
208
177
        None,
209
 
        default_test_list()
 
178
        InterRepositoryTestProviderAdapter.default_test_list()
210
179
        )
211
 
    return multiply_tests(submod_tests, scenarios, standard_tests)
 
180
    # add the tests for the sub modules
 
181
    adapt_modules(test_interrepository_implementations, adapter, loader, result)
 
182
    return result