~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

• browse files at revision 4325.4.2
• compare with another revision
• download diff
• download tarball
• view history from revision 4325.4.2

• reverse the comparison (4325.4.2 to 4595.7.3)
• stop comparing with revision 4595.7.3

Show diffs side-by-side

added

removed

bzrlib/tests/test_smart.py

29

29

import tarfile

30

30

 

31

31

from bzrlib import (

32

 

    bencode,

33

32

    bzrdir,

34

33

    errors,

35

34

    pack,

52

51

    split_suite_by_re,

53

52

    )

54

53

from bzrlib.transport import chroot, get_transport

 

54

from bzrlib.util import bencode

55

55

 

56

56

 

57

57

def load_tests(standard_tests, module, loader):

351

351

 

352

352

 

353

353

class TestSmartServerRequestBzrDirInitializeEx(tests.TestCaseWithMemoryTransport):

354

 

    """Basic tests for BzrDir.initialize_ex_1.16 in the smart server.

 

354

    """Basic tests for BzrDir.initialize_ex in the smart server.

355

355

 

356

356

    The main unit tests in test_bzrdir exercise the API comprehensively.

357

357

    """

381

381

            'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')

382

382

 

383

383

    def test_initialized_dir(self):

384

 

        """Initializing an extant directory should fail like the bzrdir api."""

 

384

        """Initializing an extant dirctory should fail like the bzrdir api."""

385

385

        backing = self.get_transport()

386

386

        name = self.make_bzrdir('reference')._format.network_name()

387

387

        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)

586

586

            '')

587

587

        self.assertEqual(SuccessfulSmartServerResponse(()), result)

588

588

        self.assertEqual('bar', config.get_option('foo'))

589

 

        # Cleanup

590

 

        branch.unlock()

591

589

 

592

590

    def test_value_name_section(self):

593

591

        branch = self.make_branch('.')

599

597

            'gam')

600

598

        self.assertEqual(SuccessfulSmartServerResponse(()), result)

601

599

        self.assertEqual('bar', config.get_option('foo', 'gam'))

602

 

        # Cleanup

603

 

        branch.unlock()

604

 

 

605

 

 

606

 

class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):

607

 

    # Only called when the branch format and tags match [yay factory

608

 

    # methods] so only need to test straight forward cases.

609

 

 

610

 

    def test_set_bytes(self):

611

 

        base_branch = self.make_branch('base')

612

 

        tag_bytes = base_branch._get_tags_bytes()

613

 

        # get_lock_tokens takes out a lock.

614

 

        branch_token, repo_token = self.get_lock_tokens(base_branch)

615

 

        request = smart.branch.SmartServerBranchSetTagsBytes(

616

 

            self.get_transport())

617

 

        response = request.execute('base', branch_token, repo_token)

618

 

        self.assertEqual(None, response)

619

 

        response = request.do_chunk(tag_bytes)

620

 

        self.assertEqual(None, response)

621

 

        response = request.do_end()

622

 

        self.assertEquals(

623

 

            SuccessfulSmartServerResponse(()), response)

624

 

        base_branch.unlock()

625

 

 

626

 

    def test_lock_failed(self):

627

 

        base_branch = self.make_branch('base')

628

 

        base_branch.lock_write()

629

 

        tag_bytes = base_branch._get_tags_bytes()

630

 

        request = smart.branch.SmartServerBranchSetTagsBytes(

631

 

            self.get_transport())

632

 

        self.assertRaises(errors.TokenMismatch, request.execute,

633

 

            'base', 'wrong token', 'wrong token')

634

 

        # The request handler will keep processing the message parts, so even

635

 

        # if the request fails immediately do_chunk and do_end are still

636

 

        # called.

637

 

        request.do_chunk(tag_bytes)

638

 

        request.do_end()

639

 

        base_branch.unlock()

640

 

 

641

600

 

642

601

 

643

602

class SetLastRevisionTestBase(TestLockedBranch):

909

868

 

910

869

 

911

870

class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):

912

 

    # Only called when the branch format and tags match [yay factory

913

 

    # methods] so only need to test straight forward cases.

 

871

# Only called when the branch format and tags match [yay factory

 

872

# methods] so only need to test straight forward cases.

914

873

 

915

874

    def test_get_bytes(self):

916

875

        base_branch = self.make_branch('base')

956

915

        # with a new branch object.

957

916

        new_branch = repository.bzrdir.open_branch()

958

917

        self.assertRaises(errors.LockContention, new_branch.lock_write)

959

 

        # Cleanup

960

 

        request = smart.branch.SmartServerBranchRequestUnlock(backing)

961

 

        response = request.execute('', branch_nonce, repository_nonce)

962

918

 

963

919

    def test_lock_write_on_locked_branch(self):

964

920

        backing = self.get_transport()

965

921

        request = smart.branch.SmartServerBranchRequestLockWrite(backing)

966

922

        branch = self.make_branch('.')

967

 

        branch_token = branch.lock_write()

 

923

        branch.lock_write()

968

924

        branch.leave_lock_in_place()

969

925

        branch.unlock()

970

926

        response = request.execute('')

971

927

        self.assertEqual(

972

928

            SmartServerResponse(('LockContention',)), response)

973

 

        # Cleanup

974

 

        branch.lock_write(branch_token)

975

 

        branch.dont_leave_lock_in_place()

976

 

        branch.unlock()

977

929

 

978

930

    def test_lock_write_with_tokens_on_locked_branch(self):

979

931

        backing = self.get_transport()

989

941

                                   branch_token, repo_token)

990

942

        self.assertEqual(

991

943

            SmartServerResponse(('ok', branch_token, repo_token)), response)

992

 

        # Cleanup

993

 

        branch.repository.lock_write(repo_token)

994

 

        branch.repository.dont_leave_lock_in_place()

995

 

        branch.repository.unlock()

996

 

        branch.lock_write(branch_token)

997

 

        branch.dont_leave_lock_in_place()

998

 

        branch.unlock()

999

944

 

1000

945

    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):

1001

946

        backing = self.get_transport()

1011

956

                                   branch_token+'xxx', repo_token)

1012

957

        self.assertEqual(

1013

958

            SmartServerResponse(('TokenMismatch',)), response)

1014

 

        # Cleanup

1015

 

        branch.repository.lock_write(repo_token)

1016

 

        branch.repository.dont_leave_lock_in_place()

1017

 

        branch.repository.unlock()

1018

 

        branch.lock_write(branch_token)

1019

 

        branch.dont_leave_lock_in_place()

1020

 

        branch.unlock()

1021

959

 

1022

960

    def test_lock_write_on_locked_repo(self):

1023

961

        backing = self.get_transport()

1024

962

        request = smart.branch.SmartServerBranchRequestLockWrite(backing)

1025

963

        branch = self.make_branch('.', format='knit')

1026

 

        repo = branch.repository

1027

 

        repo_token = repo.lock_write()

1028

 

        repo.leave_lock_in_place()

1029

 

        repo.unlock()

 

964

        branch.repository.lock_write()

 

965

        branch.repository.leave_lock_in_place()

 

966

        branch.repository.unlock()

1030

967

        response = request.execute('')

1031

968

        self.assertEqual(

1032

969

            SmartServerResponse(('LockContention',)), response)

1033

 

        # Cleanup

1034

 

        repo.lock_write(repo_token)

1035

 

        repo.dont_leave_lock_in_place()

1036

 

        repo.unlock()

1037

970

 

1038

971

    def test_lock_write_on_readonly_transport(self):

1039

972

        backing = self.get_readonly_transport()

1098

1031

            '', 'branch token', repo_token)

1099

1032

        self.assertEqual(

1100

1033

            SmartServerResponse(('TokenMismatch',)), response)

1101

 

        # Cleanup

1102

 

        branch.repository.lock_write(repo_token)

1103

 

        branch.repository.dont_leave_lock_in_place()

1104

 

        branch.repository.unlock()

1105

1034

 

1106

1035

 

1107

1036

class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):

1198

1127

            request.execute('', 'missingrevision'))

1199

1128

 

1200

1129

 

1201

 

class TestSmartServerRepositoryGetRevIdForRevno(tests.TestCaseWithMemoryTransport):

1202

 

 

1203

 

    def test_revno_found(self):

1204

 

        backing = self.get_transport()

1205

 

        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)

1206

 

        tree = self.make_branch_and_memory_tree('.')

1207

 

        tree.lock_write()

1208

 

        tree.add('')

1209

 

        rev1_id_utf8 = u'\xc8'.encode('utf-8')

1210

 

        rev2_id_utf8 = u'\xc9'.encode('utf-8')

1211

 

        tree.commit('1st commit', rev_id=rev1_id_utf8)

1212

 

        tree.commit('2nd commit', rev_id=rev2_id_utf8)

1213

 

        tree.unlock()

1214

 

 

1215

 

        self.assertEqual(SmartServerResponse(('ok', rev1_id_utf8)),

1216

 

            request.execute('', 1, (2, rev2_id_utf8)))

1217

 

 

1218

 

    def test_known_revid_missing(self):

1219

 

        backing = self.get_transport()

1220

 

        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)

1221

 

        repo = self.make_repository('.')

1222

 

        self.assertEqual(

1223

 

            FailedSmartServerResponse(('nosuchrevision', 'ghost')),

1224

 

            request.execute('', 1, (2, 'ghost')))

1225

 

 

1226

 

    def test_history_incomplete(self):

1227

 

        backing = self.get_transport()

1228

 

        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)

1229

 

        parent = self.make_branch_and_memory_tree('parent', format='1.9')

1230

 

        parent.lock_write()

1231

 

        parent.add([''], ['TREE_ROOT'])

1232

 

        r1 = parent.commit(message='first commit')

1233

 

        r2 = parent.commit(message='second commit')

1234

 

        parent.unlock()

1235

 

        local = self.make_branch_and_memory_tree('local', format='1.9')

1236

 

        local.branch.pull(parent.branch)

1237

 

        local.set_parent_ids([r2])

1238

 

        r3 = local.commit(message='local commit')

1239

 

        local.branch.create_clone_on_transport(

1240

 

            self.get_transport('stacked'), stacked_on=self.get_url('parent'))

1241

 

        self.assertEqual(

1242

 

            SmartServerResponse(('history-incomplete', 2, r2)),

1243

 

            request.execute('stacked', 1, (3, r3)))

1244

 

 

1245

1130

class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):

1246

1131

 

1247

1132

    def make_two_commit_repo(self):

1397

1282

        # object.

1398

1283

        new_repo = repository.bzrdir.open_repository()

1399

1284

        self.assertRaises(errors.LockContention, new_repo.lock_write)

1400

 

        # Cleanup

1401

 

        request = smart.repository.SmartServerRepositoryUnlock(backing)

1402

 

        response = request.execute('', nonce)

1403

1285

 

1404

1286

    def test_lock_write_on_locked_repo(self):

1405

1287

        backing = self.get_transport()

1406

1288

        request = smart.repository.SmartServerRepositoryLockWrite(backing)

1407

1289

        repository = self.make_repository('.', format='knit')

1408

 

        repo_token = repository.lock_write()

 

1290

        repository.lock_write()

1409

1291

        repository.leave_lock_in_place()

1410

1292

        repository.unlock()

1411

1293

        response = request.execute('')

1412

1294

        self.assertEqual(

1413

1295

            SmartServerResponse(('LockContention',)), response)

1414

 

        # Cleanup

1415

 

        repository.lock_write(repo_token)

1416

 

        repository.dont_leave_lock_in_place()

1417

 

        repository.unlock()

1418

1296

 

1419

1297

    def test_lock_write_on_readonly_transport(self):

1420

1298

        backing = self.get_readonly_transport()

1641

1519

            smart.bzrdir.SmartServerRequestFindRepositoryV2)

1642

1520

        self.assertHandlerEqual('BzrDirFormat.initialize',

1643

1521

            smart.bzrdir.SmartServerRequestInitializeBzrDir)

1644

 

        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',

 

1522

        self.assertHandlerEqual('BzrDirFormat.initialize_ex',

1645

1523

            smart.bzrdir.SmartServerRequestBzrDirInitializeEx)

1646

1524

        self.assertHandlerEqual('BzrDir.cloning_metadir',

1647

1525

            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)

1657

1535

            smart.repository.SmartServerRepositoryGatherStats)

1658

1536

        self.assertHandlerEqual('Repository.get_parent_map',

1659

1537

            smart.repository.SmartServerRepositoryGetParentMap)

1660

 

        self.assertHandlerEqual('Repository.get_rev_id_for_revno',

1661

 

            smart.repository.SmartServerRepositoryGetRevIdForRevno)

1662

1538

        self.assertHandlerEqual('Repository.get_revision_graph',

1663

1539

            smart.repository.SmartServerRepositoryGetRevisionGraph)

1664

1540

        self.assertHandlerEqual('Repository.get_stream',

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1