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

Merge upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart.py
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the smart wire/domain protocol.
18
18
 
177
177
        self.assertEqual(expected, request.execute('', 'False'))
178
178
 
179
179
    def test_cloning_metadir_reference(self):
180
 
        """The request works when bzrdir contains a branch reference."""
 
180
        """The request fails when bzrdir contains a branch reference."""
181
181
        backing = self.get_transport()
182
182
        referenced_branch = self.make_branch('referenced')
183
183
        dir = self.make_bzrdir('.')
189
189
        backing.rename('referenced', 'moved')
190
190
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
191
191
        request = request_class(backing)
192
 
        expected = SuccessfulSmartServerResponse(
193
 
            (local_result.network_name(),
194
 
            local_result.repository_format.network_name(),
195
 
            ('ref', reference_url)))
 
192
        expected = FailedSmartServerResponse(('BranchReference',))
196
193
        self.assertEqual(expected, request.execute('', 'False'))
197
194
 
198
195
 
389
386
        self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
390
387
            request.execute('reference'))
391
388
 
 
389
    def test_stacked_branch(self):
 
390
        """Opening a stacked branch does not open the stacked-on branch."""
 
391
        trunk = self.make_branch('trunk')
 
392
        feature = self.make_branch('feature', format='1.9')
 
393
        feature.set_stacked_on_url(trunk.base)
 
394
        opened_branches = []
 
395
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
 
396
        backing = self.get_transport()
 
397
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
398
        request.setup_jail()
 
399
        try:
 
400
            response = request.execute('feature')
 
401
        finally:
 
402
            request.teardown_jail()
 
403
        expected_format = feature._format.network_name()
 
404
        self.assertEqual(
 
405
            SuccessfulSmartServerResponse(('branch', expected_format)),
 
406
            response)
 
407
        self.assertLength(1, opened_branches)
 
408
 
392
409
 
393
410
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
394
411
 
914
931
 
915
932
        self.assertEqual(None,
916
933
            request.execute('', 'missing-id'))
917
 
        # Note that it returns a body (of '' bzipped).
 
934
        # Note that it returns a body that is bzipped.
918
935
        self.assertEqual(
919
936
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
920
937
            request.do_body('\n\n0\n'))
921
938
 
 
939
    def test_trivial_include_missing(self):
 
940
        backing = self.get_transport()
 
941
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
 
942
        tree = self.make_branch_and_memory_tree('.')
 
943
 
 
944
        self.assertEqual(None,
 
945
            request.execute('', 'missing-id', 'include-missing:'))
 
946
        self.assertEqual(
 
947
            SuccessfulSmartServerResponse(('ok', ),
 
948
                bz2.compress('missing:missing-id')),
 
949
            request.do_body('\n\n0\n'))
 
950
 
922
951
 
923
952
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
924
953
 
1114
1143
 
1115
1144
class TestSmartServerRepositoryLockWrite(tests.TestCaseWithMemoryTransport):
1116
1145
 
1117
 
    def setUp(self):
1118
 
        tests.TestCaseWithMemoryTransport.setUp(self)
1119
 
 
1120
1146
    def test_lock_write_on_unlocked_repo(self):
1121
1147
        backing = self.get_transport()
1122
1148
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1149
1175
        self.assertEqual('LockFailed', response.args[0])
1150
1176
 
1151
1177
 
 
1178
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
 
1179
 
 
1180
    def make_empty_byte_stream(self, repo):
 
1181
        byte_stream = smart.repository._stream_to_byte_stream([], repo._format)
 
1182
        return ''.join(byte_stream)
 
1183
 
 
1184
 
 
1185
class TestSmartServerRepositoryInsertStream(TestInsertStreamBase):
 
1186
 
 
1187
    def test_insert_stream_empty(self):
 
1188
        backing = self.get_transport()
 
1189
        request = smart.repository.SmartServerRepositoryInsertStream(backing)
 
1190
        repository = self.make_repository('.')
 
1191
        response = request.execute('', '')
 
1192
        self.assertEqual(None, response)
 
1193
        response = request.do_chunk(self.make_empty_byte_stream(repository))
 
1194
        self.assertEqual(None, response)
 
1195
        response = request.do_end()
 
1196
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1197
        
 
1198
 
 
1199
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
 
1200
 
 
1201
    def test_insert_stream_empty(self):
 
1202
        backing = self.get_transport()
 
1203
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
 
1204
            backing)
 
1205
        repository = self.make_repository('.', format='knit')
 
1206
        lock_token = repository.lock_write()
 
1207
        response = request.execute('', '', lock_token)
 
1208
        self.assertEqual(None, response)
 
1209
        response = request.do_chunk(self.make_empty_byte_stream(repository))
 
1210
        self.assertEqual(None, response)
 
1211
        response = request.do_end()
 
1212
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1213
        repository.unlock()
 
1214
 
 
1215
    def test_insert_stream_with_wrong_lock_token(self):
 
1216
        backing = self.get_transport()
 
1217
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
 
1218
            backing)
 
1219
        repository = self.make_repository('.', format='knit')
 
1220
        lock_token = repository.lock_write()
 
1221
        self.assertRaises(
 
1222
            errors.TokenMismatch, request.execute, '', '', 'wrong-token')
 
1223
        repository.unlock()
 
1224
 
 
1225
 
1152
1226
class TestSmartServerRepositoryUnlock(tests.TestCaseWithMemoryTransport):
1153
1227
 
1154
1228
    def setUp(self):
1237
1311
 
1238
1312
    def test_autopack_needed(self):
1239
1313
        repo = self.make_repo_needing_autopacking()
 
1314
        repo.lock_write()
 
1315
        self.addCleanup(repo.unlock)
1240
1316
        backing = self.get_transport()
1241
1317
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1242
1318
            backing)
1248
1324
    def test_autopack_not_needed(self):
1249
1325
        tree = self.make_branch_and_tree('.', format='pack-0.92')
1250
1326
        repo = tree.branch.repository
 
1327
        repo.lock_write()
 
1328
        self.addCleanup(repo.unlock)
1251
1329
        for x in range(9):
1252
1330
            tree.commit('commit %s' % x)
1253
1331
        backing = self.get_transport()
1339
1417
                'Repository.get_revision_graph'),
1340
1418
            smart.repository.SmartServerRepositoryGetRevisionGraph)
1341
1419
        self.assertEqual(
 
1420
            smart.request.request_handlers.get('Repository.get_stream'),
 
1421
            smart.repository.SmartServerRepositoryGetStream)
 
1422
        self.assertEqual(
1342
1423
            smart.request.request_handlers.get('Repository.has_revision'),
1343
1424
            smart.repository.SmartServerRequestHasRevision)
1344
1425
        self.assertEqual(
 
1426
            smart.request.request_handlers.get('Repository.insert_stream'),
 
1427
            smart.repository.SmartServerRepositoryInsertStream)
 
1428
        self.assertEqual(
 
1429
            smart.request.request_handlers.get('Repository.insert_stream_locked'),
 
1430
            smart.repository.SmartServerRepositoryInsertStreamLocked)
 
1431
        self.assertEqual(
1345
1432
            smart.request.request_handlers.get('Repository.is_shared'),
1346
1433
            smart.repository.SmartServerRepositoryIsShared)
1347
1434
        self.assertEqual(
1348
1435
            smart.request.request_handlers.get('Repository.lock_write'),
1349
1436
            smart.repository.SmartServerRepositoryLockWrite)
1350
1437
        self.assertEqual(
1351
 
            smart.request.request_handlers.get('Repository.get_stream'),
1352
 
            smart.repository.SmartServerRepositoryGetStream)
1353
 
        self.assertEqual(
1354
1438
            smart.request.request_handlers.get('Repository.tarball'),
1355
1439
            smart.repository.SmartServerRepositoryTarball)
1356
1440
        self.assertEqual(