~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Matt Nordhoff
  • Date: 2009-04-04 02:50:01 UTC
  • mfrom: (4253 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4256.
  • Revision ID: mnordhoff@mattnordhoff.com-20090404025001-z1403k0tatmc8l91
Merge bzr.dev, fixing conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 
19
19
 
20
20
"""Branch implementation tests for bzr.
21
21
 
22
22
These test the conformance of all the branch variations to the expected API.
23
 
Specific tests for individual formats are in the tests/test_branch file 
 
23
Specific tests for individual formats are in the tests/test_branch file
24
24
rather than in tests/branch_implementations/*.py.
25
25
"""
26
26
 
42
42
from bzrlib.transport.memory import MemoryServer
43
43
 
44
44
 
45
 
class BranchTestProviderAdapter(tests.TestScenarioApplier):
46
 
    """A tool to generate a suite testing multiple branch formats at once.
 
45
def make_scenarios(transport_server, transport_readonly_server,
 
46
    formats, vfs_transport_factory=None, name_suffix=''):
 
47
    """Transform the input formats to a list of scenarios.
47
48
 
48
 
    This is done by copying the test once for each transport and injecting
49
 
    the transport_server, transport_readonly_server, and branch_format
50
 
    classes into each copy. Each copy is also given a new id() to make it
51
 
    easy to identify.
 
49
    :param formats: A list of (branch_format, bzrdir_format).
52
50
    """
53
 
 
54
 
    def __init__(self, transport_server, transport_readonly_server, formats,
55
 
        vfs_transport_factory=None, name_suffix=''):
56
 
        self._transport_server = transport_server
57
 
        self._transport_readonly_server = transport_readonly_server
58
 
        self._name_suffix = name_suffix
59
 
        self.scenarios = self.formats_to_scenarios(formats)
60
 
    
61
 
    def formats_to_scenarios(self, formats):
62
 
        """Transform the input formats to a list of scenarios.
63
 
 
64
 
        :param formats: A list of (branch_format, bzrdir_format).
65
 
        """
66
 
        result = []
67
 
        for branch_format, bzrdir_format in formats:
68
 
            # some branches don't have separate format objects.
69
 
            # so we have a conditional here to handle them.
70
 
            scenario_name = getattr(branch_format, '__name__',
71
 
                branch_format.__class__.__name__)
72
 
            scenario_name += self._name_suffix
73
 
            scenario = (scenario_name, {
74
 
                "transport_server":self._transport_server,
75
 
                "transport_readonly_server":self._transport_readonly_server,
76
 
                "bzrdir_format":bzrdir_format,
77
 
                "branch_format":branch_format,
78
 
                    })
79
 
            result.append(scenario)
80
 
        return result
 
51
    result = []
 
52
    for branch_format, bzrdir_format in formats:
 
53
        # some branches don't have separate format objects.
 
54
        # so we have a conditional here to handle them.
 
55
        scenario_name = getattr(branch_format, '__name__',
 
56
            branch_format.__class__.__name__)
 
57
        scenario_name += name_suffix
 
58
        scenario = (scenario_name, {
 
59
            "transport_server":transport_server,
 
60
            "transport_readonly_server":transport_readonly_server,
 
61
            "bzrdir_format":bzrdir_format,
 
62
            "branch_format":branch_format,
 
63
                })
 
64
        result.append(scenario)
 
65
    return result
81
66
 
82
67
 
83
68
class TestCaseWithBranch(TestCaseWithBzrDir):
84
 
    """This helper will be adapted for each branch_implementation test."""
 
69
    """This helper will be parameterised in each branch_implementation test."""
85
70
 
86
71
    def setUp(self):
87
72
        super(TestCaseWithBranch, self).setUp()
145
130
        return tree
146
131
 
147
132
 
148
 
def load_tests(basic_tests, module, loader):
149
 
    result = loader.suiteClass()
150
 
    # add the tests for this module
151
 
    result.addTests(basic_tests)
152
 
 
 
133
def branch_scenarios():
 
134
    """ """
 
135
    # Generate a list of branch formats and their associated bzrdir formats to
 
136
    # use.
 
137
    combinations = [(format, format._matchingbzrdir) for format in
 
138
         BranchFormat._formats.values() + _legacy_formats]
 
139
    scenarios = make_scenarios(
 
140
        # None here will cause the default vfs transport server to be used.
 
141
        None,
 
142
        # None here will cause a readonly decorator to be created
 
143
        # by the TestCaseWithTransport.get_readonly_transport method.
 
144
        None,
 
145
        combinations)
 
146
    # Add RemoteBranch tests, which need a special server.
 
147
    remote_branch_format = RemoteBranchFormat()
 
148
    scenarios.extend(make_scenarios(
 
149
        SmartTCPServer_for_testing,
 
150
        ReadonlySmartTCPServer_for_testing,
 
151
        [(remote_branch_format, remote_branch_format._matchingbzrdir)],
 
152
        MemoryServer,
 
153
        name_suffix='-default'))
 
154
    # Also add tests for RemoteBranch with HPSS protocol v2 (i.e. bzr <1.6)
 
155
    # server.
 
156
    scenarios.extend(make_scenarios(
 
157
        SmartTCPServer_for_testing_v2_only,
 
158
        ReadonlySmartTCPServer_for_testing_v2_only,
 
159
        [(remote_branch_format, remote_branch_format._matchingbzrdir)],
 
160
        MemoryServer,
 
161
        name_suffix='-v2'))
 
162
    return scenarios
 
163
 
 
164
 
 
165
def load_tests(standard_tests, module, loader):
153
166
    test_branch_implementations = [
154
167
        'bzrlib.tests.branch_implementations.test_bound_sftp',
155
168
        'bzrlib.tests.branch_implementations.test_branch',
156
169
        'bzrlib.tests.branch_implementations.test_break_lock',
157
170
        'bzrlib.tests.branch_implementations.test_check',
158
171
        'bzrlib.tests.branch_implementations.test_create_checkout',
 
172
        'bzrlib.tests.branch_implementations.test_create_clone',
159
173
        'bzrlib.tests.branch_implementations.test_commit',
160
174
        'bzrlib.tests.branch_implementations.test_dotted_revno_to_revision_id',
161
175
        'bzrlib.tests.branch_implementations.test_get_revision_id_to_revno_map',
178
192
        'bzrlib.tests.branch_implementations.test_uncommit',
179
193
        'bzrlib.tests.branch_implementations.test_update',
180
194
        ]
181
 
    # Generate a list of branch formats and their associated bzrdir formats to
182
 
    # use.
183
 
    combinations = [(format, format._matchingbzrdir) for format in 
184
 
         BranchFormat._formats.values() + _legacy_formats]
185
 
    adapter = BranchTestProviderAdapter(
186
 
        # None here will cause the default vfs transport server to be used.
187
 
        None,
188
 
        # None here will cause a readonly decorator to be created
189
 
        # by the TestCaseWithTransport.get_readonly_transport method.
190
 
        None,
191
 
        combinations)
192
 
    # add the tests for the sub modules
193
 
    tests.adapt_modules(test_branch_implementations, adapter, loader, result)
194
 
 
195
 
    # Add RemoteBranch tests, which need a special server.
196
 
    remote_branch_format = RemoteBranchFormat()
197
 
    adapt_to_smart_server = BranchTestProviderAdapter(
198
 
        SmartTCPServer_for_testing,
199
 
        ReadonlySmartTCPServer_for_testing,
200
 
        [(remote_branch_format, remote_branch_format._matchingbzrdir)],
201
 
        MemoryServer,
202
 
        name_suffix='-default')
203
 
    tests.adapt_modules(test_branch_implementations,
204
 
                        adapt_to_smart_server,
205
 
                        loader,
206
 
                        result)
207
 
 
208
 
    # Also add tests for RemoteBranch with HPSS protocol v2 (i.e. bzr <1.6)
209
 
    # server.
210
 
    adapt_to_smart_server = BranchTestProviderAdapter(
211
 
        SmartTCPServer_for_testing_v2_only,
212
 
        ReadonlySmartTCPServer_for_testing_v2_only,
213
 
        [(remote_branch_format, remote_branch_format._matchingbzrdir)],
214
 
        MemoryServer,
215
 
        name_suffix='-v2')
216
 
    tests.adapt_modules(test_branch_implementations,
217
 
                        adapt_to_smart_server,
218
 
                        loader,
219
 
                        result)
220
 
 
221
 
    return result
 
195
    sub_tests = loader.loadTestsFromModuleNames(test_branch_implementations)
 
196
    return tests.multiply_tests(sub_tests, branch_scenarios(), standard_tests)