~bzr-pqm/bzr/bzr.dev : revision 3428

132

class FakeClient(_SmartClient):

133

"""Lookalike for _SmartClient allowing testing."""

134

135

def __init__(self, responses, fake_medium_base='fake base'):

135

def __init__(self, fake_medium_base='fake base'):

136

"""Create a FakeClient.

137

138

:param responses: A list of response-tuple, body-data pairs to be sent

141

call, using the second element of the tuple as the verb in the

142

exception.

143

"""

144

self.responses = responses

144

self.responses = []

145

self._calls = []

146

self.expecting_body = False

147

_SmartClient.__init__(self, FakeMedium(self._calls), fake_medium_base)

148

149

def add_success_response(self, *args):

150

self.responses.append(('success', args, None))

151

152

def add_success_response_with_body(self, body, *args):

153

self.responses.append(('success', args, body))

154

155

def add_error_response(self, *args):

156

self.responses.append(('error', args))

157

158

def add_unknown_method_response(self, verb):

159

self.responses.append(('unknown', verb))

160

149

161

def _get_next_response(self):

150

162

response_tuple = self.responses.pop(0)

151

if response_tuple[0][0] == 'unknown verb':

152

raise errors.UnknownSmartMethod(response_tuple[0][1])

163

if response_tuple[0] == 'unknown':

164

raise errors.UnknownSmartMethod(response_tuple[1])

165

elif response_tuple[0] == 'error':

166

raise errors.ErrorFromSmartServer(response_tuple[1])

153

167

return response_tuple

154

168

155

169

def call(self, method, *args):

156

170

self._calls.append(('call', method, args))

157

return self._get_next_response()[0]

171

return self._get_next_response()[1]

158

172

159

173

def call_expecting_body(self, method, *args):

160

174

self._calls.append(('call_expecting_body', method, args))

161

175

result = self._get_next_response()

162

176

self.expecting_body = True

163

return result[0], FakeProtocol(result[1], self)

177

return result[1], FakeProtocol(result[2], self)

164

178

165

179

def call_with_body_bytes_expecting_body(self, method, args, body):

166

180

self._calls.append(('call_with_body_bytes_expecting_body', method,

167

181

args, body))

168

182

result = self._get_next_response()

169

183

self.expecting_body = True

170

return result[0], FakeProtocol(result[1], self)

184

return result[1], FakeProtocol(result[2], self)

171

185

172

186

173

187

class FakeMedium(object):

183

197

class TestVfsHas(tests.TestCase):

184

198

185

199

def test_unicode_path(self):

186

client = FakeClient([(('yes',), )], '/')

200

client = FakeClient('/')

201

client.add_success_response('yes',)

187

202

transport = RemoteTransport('bzr://localhost/', _client=client)

188

203

filename = u'/hell\u00d8'.encode('utf8')

189

204

result = transport.has(filename)

232

247

transport = MemoryTransport()

233

248

transport.mkdir('quack')

234

249

transport = transport.clone('quack')

235

client = FakeClient([(('ok', ''), ), (('ok', '', 'no', 'no', 'no'), )],

236

transport.base)

250

client = FakeClient(transport.base)

251

client.add_success_response('ok', '')

252

client.add_success_response('ok', '', 'no', 'no', 'no')

237

253

bzrdir = RemoteBzrDir(transport, _client=client)

238

254

result = bzrdir.open_branch()

239

255

self.assertEqual(

247

263

transport = MemoryTransport()

248

264

transport.mkdir('quack')

249

265

transport = transport.clone('quack')

250

client = FakeClient([(('nobranch',), )], transport.base)

266

client = FakeClient(transport.base)

267

client.add_error_response('nobranch')

251

268

bzrdir = RemoteBzrDir(transport, _client=client)

252

269

self.assertRaises(errors.NotBranchError, bzrdir.open_branch)

253

270

self.assertEqual(

263

280

return "a-branch"

264

281

transport = MemoryTransport()

265

282

# no requests on the network - catches other api calls being made.

266

client = FakeClient([], transport.base)

283

client = FakeClient(transport.base)

267

284

bzrdir = RemoteBzrDir(transport, _client=client)

268

285

# patch the open_branch call to record that it was called.

269

286

bzrdir.open_branch = open_branch

275

292

# Relpaths on the wire should not be URL-escaped. So "~" should be

276

293

# transmitted as "~", not "%7E".

277

294

transport = RemoteTransport('bzr://localhost/~hello/')

278

client = FakeClient([(('ok', ''), ), (('ok', '', 'no', 'no', 'no'), )],

279

transport.base)

295

client = FakeClient(transport.base)

296

client.add_success_response('ok', '')

297

client.add_success_response('ok', '', 'no', 'no', 'no')

280

298

bzrdir = RemoteBzrDir(transport, _client=client)

281

299

result = bzrdir.open_branch()

282

300

self.assertEqual(

296

314

subtree_response = 'yes'

297

315

else:

298

316

subtree_response = 'no'

299

client = FakeClient(

300

[(('ok', '', rich_response, subtree_response, external_lookup), ),],

301

transport.base)

317

client = FakeClient(transport.base)

318

client.add_success_response(

319

'ok', '', rich_response, subtree_response, external_lookup)

302

320

bzrdir = RemoteBzrDir(transport, _client=client)

303

321

result = bzrdir.open_repository()

304

322

self.assertEqual(

330

348

transport = MemoryTransport()

331

349

transport.mkdir('quack')

332

350

transport = transport.clone('quack')

333

client = FakeClient([

334

(('unknown verb', 'RemoteRepository.find_repositoryV2'), ''),

335

(('ok', '', 'no', 'no'), ''),],

336

transport.base)

351

client = FakeClient(transport.base)

352

client.add_unknown_method_response('RemoteRepository.find_repositoryV2')

353

client.add_success_response('ok', '', 'no', 'no')

337

354

bzrdir = RemoteBzrDir(transport, _client=client)

338

355

repo = bzrdir.open_repository()

339

356

self.assertEqual(

375

392

def test_empty_branch(self):

376

393

# in an empty branch we decode the response properly

377

394

transport = MemoryTransport()

378

client = FakeClient([(('ok', '0', 'null:'), )], transport.base)

395

client = FakeClient(transport.base)

396

client.add_success_response('ok', '0', 'null:')

379

397

transport.mkdir('quack')

380

398

transport = transport.clone('quack')

381

399

# we do not want bzrdir to make any remote calls

392

410

# in a non-empty branch we also decode the response properly

393

411

revid = u'\xc8'.encode('utf8')

394

412

transport = MemoryTransport()

395

client = FakeClient([(('ok', '2', revid), )], transport.base)

413

client = FakeClient(transport.base)

414

client.add_success_response('ok', '2', revid)

396

415

transport.mkdir('kwaak')

397

416

transport = transport.clone('kwaak')

398

417

# we do not want bzrdir to make any remote calls

415

434

transport.mkdir('branch')

416

435

transport = transport.clone('branch')

417

436

418

client = FakeClient([

419

# lock_write

420

(('ok', 'branch token', 'repo token'), ),

421

# set_last_revision

422

(('ok',), ),

423

# unlock

424

(('ok',), )],

425

transport.base)

437

client = FakeClient(transport.base)

438

# lock_write

439

client.add_success_response('ok', 'branch token', 'repo token')

440

# set_last_revision

441

client.add_success_response('ok')

442

# unlock

443

client.add_success_response('ok')

426

444

bzrdir = RemoteBzrDir(transport, _client=False)

427

445

branch = RemoteBranch(bzrdir, None, _client=client)

428

446

# This is a hack to work around the problem that RemoteBranch currently

445

463

transport.mkdir('branch')

446

464

transport = transport.clone('branch')

447

465

448

client = FakeClient([

449

# lock_write

450

(('ok', 'branch token', 'repo token'), ),

451

# set_last_revision

452

(('ok',), ),

453

# unlock

454

(('ok',), )],

455

transport.base)

466

client = FakeClient(transport.base)

467

# lock_write

468

client.add_success_response('ok', 'branch token', 'repo token')

469

# set_last_revision

470

client.add_success_response('ok')

471

# unlock

472

client.add_success_response('ok')

456

473

bzrdir = RemoteBzrDir(transport, _client=False)

457

474

branch = RemoteBranch(bzrdir, None, _client=client)

458

475

# This is a hack to work around the problem that RemoteBranch currently

471

488

self.assertEqual(None, result)

472

489

473

490

def test_no_such_revision(self):

474

# A response of 'NoSuchRevision' is translated into an exception.

475

client = FakeClient([

476

# lock_write

477

(('ok', 'branch token', 'repo token'), ),

478

# set_last_revision

479

(('NoSuchRevision', 'rev-id'), ),

480

# unlock

481

(('ok',), )])

482

491

transport = MemoryTransport()

483

492

transport.mkdir('branch')

484

493

transport = transport.clone('branch')

494

# A response of 'NoSuchRevision' is translated into an exception.

495

client = FakeClient(transport.base)

496

# lock_write

497

client.add_success_response('ok', 'branch token', 'repo token')

498

# set_last_revision

499

client.add_error_response('NoSuchRevision', 'rev-id')

500

# unlock

501

client.add_success_response('ok')

485

502

486

503

bzrdir = RemoteBzrDir(transport, _client=False)

487

504

branch = RemoteBranch(bzrdir, None, _client=client)

502

519

transport = MemoryTransport()

503

520

transport.mkdir('branch')

504

521

transport = transport.clone('branch')

505

client = FakeClient([

506

# lock_write

507

(('ok', 'branch token', 'repo token'), ),

508

# set_last_revision_info

509

(('ok',), ),

510

# unlock

511

(('ok',), )], transport.base)

522

client = FakeClient(transport.base)

523

# lock_write

524

client.add_success_response('ok', 'branch token', 'repo token')

525

# set_last_revision

526

client.add_success_response('ok')

527

# unlock

528

client.add_success_response('ok')

512

529

513

530

bzrdir = RemoteBzrDir(transport, _client=False)

514

531

branch = RemoteBranch(bzrdir, None, _client=client)

528

545

529

546

def test_no_such_revision(self):

530

547

# A response of 'NoSuchRevision' is translated into an exception.

531

client = FakeClient([

532

# lock_write

533

(('ok', 'branch token', 'repo token'), ),

534

# set_last_revision_info

535

(('NoSuchRevision', 'revid'), ),

536

# unlock

537

(('ok',), ),

538

])

539

548

transport = MemoryTransport()

540

549

transport.mkdir('branch')

541

550

transport = transport.clone('branch')

551

client = FakeClient(transport.base)

552

# lock_write

553

client.add_success_response('ok', 'branch token', 'repo token')

554

# set_last_revision

555

client.add_error_response('NoSuchRevision', 'revid')

556

# unlock

557

client.add_success_response('ok')

542

558

543

559

bzrdir = RemoteBzrDir(transport, _client=False)

544

560

branch = RemoteBranch(bzrdir, None, _client=client)

575

591

transport = MemoryTransport()

576

592

transport.mkdir('branch')

577

593

transport = transport.clone('branch')

578

client = FakeClient(

579

[(('unknown verb', 'Branch.set_last_revision_info',), ),],

580

transport.base)

594

client = FakeClient(transport.base)

595

client.add_unknown_method_response('Branch.set_last_revision_info')

581

596

bzrdir = RemoteBzrDir(transport, _client=False)

582

597

branch = RemoteBranch(bzrdir, None, _client=client)

583

598

class StubRealBranch(object):

601

616

[('set_last_revision_info', 1234, 'a-revision-id')],

602

617

real_branch.calls)

603

618

619

def test_unexpected_error(self):

620

# A response of 'NoSuchRevision' is translated into an exception.

621

transport = MemoryTransport()

622

transport.mkdir('branch')

623

transport = transport.clone('branch')

624

client = FakeClient(transport.base)

625

# lock_write

626

client.add_success_response('ok', 'branch token', 'repo token')

627

# set_last_revision

628

client.add_error_response('UnexpectedError')

629

# unlock

630

client.add_success_response('ok')

631

632

bzrdir = RemoteBzrDir(transport, _client=False)

633

branch = RemoteBranch(bzrdir, None, _client=client)

634

# This is a hack to work around the problem that RemoteBranch currently

635

# unnecessarily invokes _ensure_real upon a call to lock_write.

636

branch._ensure_real = lambda: None

637

# Lock the branch, reset the record of remote calls.

638

branch.lock_write()

639

client._calls = []

640

641

err = self.assertRaises(

642

errors.ErrorFromSmartServer,

643

branch.set_last_revision_info, 123, 'revid')

644

self.assertEqual(('UnexpectedError',), err.error_tuple)

645

branch.unlock()

646

604

647

605

648

class TestBranchControlGetBranchConf(tests.TestCaseWithMemoryTransport):

606

649

"""Getting the branch configuration should use an abstract method not vfs.

614

657

# vfs, and this would need some changes in config.py.

615

658

616

659

# in an empty branch we decode the response properly

617

client = FakeClient([(('ok', ), '# config file body')], self.get_url())

660

client = FakeClient(self.get_url())

661

client.add_success_response_with_body('# config file body', 'ok')

618

662

# we need to make a real branch because the remote_branch.control_files

619

663

# will trigger _ensure_real.

620

664

branch = self.make_branch('quack')

632

676

633

677

def test_lock_write_unlockable(self):

634

678

transport = MemoryTransport()

635

client = FakeClient([(('UnlockableTransport', ), '')], transport.base)

679

client = FakeClient(transport.base)

680

client.add_error_response('UnlockableTransport')

636

681

transport.mkdir('quack')

637

682

transport = transport.clone('quack')

638

683

# we do not want bzrdir to make any remote calls

647

692

class TestTransportIsReadonly(tests.TestCase):

648

693

649

694

def test_true(self):

650

client = FakeClient([(('yes',), '')])

695

client = FakeClient()

696

client.add_success_response('yes')

651

697

transport = RemoteTransport('bzr://example.com/', medium=False,

652

698

_client=client)

653

699

self.assertEqual(True, transport.is_readonly())

656

702

client._calls)

657

703

658

704

def test_false(self):

659

client = FakeClient([(('no',), '')])

705

client = FakeClient()

706

client.add_success_response('no')

660

707

transport = RemoteTransport('bzr://example.com/', medium=False,

661

708

_client=client)

662

709

self.assertEqual(False, transport.is_readonly())

671

718

advisory anyway (a transport could be read-write, but then the

672

719

underlying filesystem could be readonly anyway).

673

720

"""

674

client = FakeClient([(('unknown verb', 'Transport.is_readonly'), '')])

721

client = FakeClient()

722

client.add_unknown_method_response('Transport.is_readonly')

675

723

transport = RemoteTransport('bzr://example.com/', medium=False,

676

724

_client=client)

677

725

self.assertEqual(False, transport.is_readonly())

688

736

because they might break compatibility with different-versioned servers.

689

737

"""

690

738

691

def setup_fake_client_and_repository(self, responses, transport_path):

739

def setup_fake_client_and_repository(self, transport_path):

692

740

"""Create the fake client and repository for testing with.

693

741

694

742

There's no real server here; we just have canned responses sent

699

747

"""

700

748

transport = MemoryTransport()

701

749

transport.mkdir(transport_path)

702

client = FakeClient(responses, transport.base)

750

client = FakeClient(transport.base)

703

751

transport = transport.clone(transport_path)

704

752

# we do not want bzrdir to make any remote calls

705

753

bzrdir = RemoteBzrDir(transport, _client=False)

711

759

712

760

def test_revid_none(self):

713

761

# ('ok',), body with revisions and size

714

responses = [(('ok', ), 'revisions: 2\nsize: 18\n')]

715

762

transport_path = 'quack'

716

repo, client = self.setup_fake_client_and_repository(

717

responses, transport_path)

763

repo, client = self.setup_fake_client_and_repository(transport_path)

764

client.add_success_response_with_body(

765

'revisions: 2\nsize: 18\n', 'ok')

718

766

result = repo.gather_stats(None)

719

767

self.assertEqual(

720

768

[('call_expecting_body', 'Repository.gather_stats',

724

772

725

773

def test_revid_no_committers(self):

726

774

# ('ok',), body without committers

727

responses = [(('ok', ),

728

'firstrev: 123456.300 3600\n'

729

'latestrev: 654231.400 0\n'

730

'revisions: 2\n'

731

'size: 18\n')]

775

body = ('firstrev: 123456.300 3600\n'

776

'latestrev: 654231.400 0\n'

777

'revisions: 2\n'

778

'size: 18\n')

732

779

transport_path = 'quick'

733

780

revid = u'\xc8'.encode('utf8')

734

repo, client = self.setup_fake_client_and_repository(

735

responses, transport_path)

781

repo, client = self.setup_fake_client_and_repository(transport_path)

782

client.add_success_response_with_body(body, 'ok')

736

783

result = repo.gather_stats(revid)

737

784

self.assertEqual(

738

785

[('call_expecting_body', 'Repository.gather_stats',

745

792

746

793

def test_revid_with_committers(self):

747

794

# ('ok',), body with committers

748

responses = [(('ok', ),

749

'committers: 128\n'

750

'firstrev: 123456.300 3600\n'

751

'latestrev: 654231.400 0\n'

752

'revisions: 2\n'

753

'size: 18\n')]

795

body = ('committers: 128\n'

796

'firstrev: 123456.300 3600\n'

797

'latestrev: 654231.400 0\n'

798

'revisions: 2\n'

799

'size: 18\n')

754

800

transport_path = 'buick'

755

801

revid = u'\xc8'.encode('utf8')

756

repo, client = self.setup_fake_client_and_repository(

757

responses, transport_path)

802

repo, client = self.setup_fake_client_and_repository(transport_path)

803

client.add_success_response_with_body(body, 'ok')

758

804

result = repo.gather_stats(revid, True)

759

805

self.assertEqual(

760

806

[('call_expecting_body', 'Repository.gather_stats',

772

818

def test_get_graph(self):

773

819

# get_graph returns a graph with the repository as the

774

820

# parents_provider.

775

responses = []

776

821

transport_path = 'quack'

777

repo, client = self.setup_fake_client_and_repository(

778

responses, transport_path)

822

repo, client = self.setup_fake_client_and_repository(transport_path)

779

823

graph = repo.get_graph()

780

824

self.assertEqual(graph._parents_provider, repo)

781

825

789

833

r2 = u'\u0dab'.encode('utf8')

790

834

lines = [' '.join([r2, r1]), r1]

791

835

encoded_body = bz2.compress('\n'.join(lines))

792

responses = [(('ok', ), encoded_body), (('ok', ), encoded_body)]

793

836

794

837

transport_path = 'quack'

795

repo, client = self.setup_fake_client_and_repository(

796

responses, transport_path)

838

repo, client = self.setup_fake_client_and_repository(transport_path)

839

client.add_success_response_with_body(encoded_body, 'ok')

840

client.add_success_response_with_body(encoded_body, 'ok')

797

841

repo.lock_read()

798

842

graph = repo.get_graph()

799

843

parents = graph.get_parent_map([r2])

823

867

repo.unlock()

824

868

825

869

def test_get_parent_map_reconnects_if_unknown_method(self):

826

responses = [

827

(('unknown verb', 'Repository.get_parent_map'), ''),

828

(('ok',), '')]

829

870

transport_path = 'quack'

830

repo, client = self.setup_fake_client_and_repository(

831

responses, transport_path)

871

repo, client = self.setup_fake_client_and_repository(transport_path)

872

client.add_unknown_method_response('Repository,get_parent_map')

873

client.add_success_response_with_body('', 'ok')

832

874

self.assertTrue(client._medium._remote_is_at_least_1_2)

833

875

rev_id = 'revision-id'

834

876

expected_deprecations = [

858

900

This is the test for https://bugs.launchpad.net/bzr/+bug/214894

859

901

"""

860

902

rev_id = 'revision-id'

861

responses = [(('ok',), rev_id)]

862

903

transport_path = 'quack'

863

repo, client = self.setup_fake_client_and_repository(

864

responses, transport_path)

904

repo, client = self.setup_fake_client_and_repository(transport_path)

905

client.add_success_response_with_body(rev_id, 'ok')

865

906

client._medium._remote_is_at_least_1_2 = False

866

907

expected_deprecations = [

867

908

'bzrlib.remote.RemoteRepository.get_revision_graph was deprecated '

875

916

self.assertEqual({rev_id: ('null:',)}, parents)

876

917

877

918

def test_get_parent_map_unexpected_response(self):

878

responses = [

879

(('something unexpected!',), '')]

880

repo, client = self.setup_fake_client_and_repository(responses, 'path')

919

repo, client = self.setup_fake_client_and_repository('path')

920

client.add_success_response('something unexpected!')

881

921

self.assertRaises(

882

922

errors.UnexpectedSmartServerResponse,

883

923

repo.get_parent_map, ['a-revision-id'])

888

928

def test_null_revision(self):

889

929

# a null revision has the predictable result {}, we should have no wire

890

930

# traffic when calling it with this argument

891

responses = [(('notused', ), '')]

892

931

transport_path = 'empty'

893

repo, client = self.setup_fake_client_and_repository(

894

responses, transport_path)

932

repo, client = self.setup_fake_client_and_repository(transport_path)

933

client.add_success_response('notused')

895

934

result = self.applyDeprecated(one_four, repo.get_revision_graph,

896

935

NULL_REVISION)

897

936

self.assertEqual([], client._calls)

904

943

lines = [' '.join([r2, r1]), r1]

905

944

encoded_body = '\n'.join(lines)

906

945

907

responses = [(('ok', ), encoded_body)]

908

946

transport_path = 'sinhala'

909

repo, client = self.setup_fake_client_and_repository(

910

responses, transport_path)

947

repo, client = self.setup_fake_client_and_repository(transport_path)

948

client.add_success_response_with_body(encoded_body, 'ok')

911

949

result = self.applyDeprecated(one_four, repo.get_revision_graph)

912

950

self.assertEqual(

913

951

[('call_expecting_body', 'Repository.get_revision_graph',

924

962

lines = [' '.join([r2, r11, r12]), r11, r12]

925

963

encoded_body = '\n'.join(lines)

926

964

927

responses = [(('ok', ), encoded_body)]

928

965

transport_path = 'sinhala'

929

repo, client = self.setup_fake_client_and_repository(

930

responses, transport_path)

966

repo, client = self.setup_fake_client_and_repository(transport_path)

967

client.add_success_response_with_body(encoded_body, 'ok')

931

968

result = self.applyDeprecated(one_four, repo.get_revision_graph, r2)

932

969

self.assertEqual(

933

970

[('call_expecting_body', 'Repository.get_revision_graph',

937

974

938

975

def test_no_such_revision(self):

939

976

revid = '123'

940

responses = [(('nosuchrevision', revid), '')]

941

977

transport_path = 'sinhala'

942

repo, client = self.setup_fake_client_and_repository(

943

responses, transport_path)

978

repo, client = self.setup_fake_client_and_repository(transport_path)

979

client.add_error_response('nosuchrevision', revid)

944

980

# also check that the right revision is reported in the error

945

981

self.assertRaises(errors.NoSuchRevision,

946

982

self.applyDeprecated, one_four, repo.get_revision_graph, revid)

949

985

('sinhala/', revid))],

950

986

client._calls)

951

987

988

def test_unexpected_error(self):

989

revid = '123'

990

transport_path = 'sinhala'

991

repo, client = self.setup_fake_client_and_repository(transport_path)

992

client.add_error_response('AnUnexpectedError')

993

e = self.assertRaises(errors.ErrorFromSmartServer,

994

self.applyDeprecated, one_four, repo.get_revision_graph, revid)

995

self.assertEqual(('AnUnexpectedError',), e.error_tuple)

996

952

997

953

998

class TestRepositoryIsShared(TestRemoteRepository):

954

999

955

1000

def test_is_shared(self):

956

1001

# ('yes', ) for Repository.is_shared -> 'True'.

957

responses = [(('yes', ), )]

958

1002

transport_path = 'quack'

959

repo, client = self.setup_fake_client_and_repository(

960

responses, transport_path)

1003

repo, client = self.setup_fake_client_and_repository(transport_path)

1004

client.add_success_response('yes')

961

1005

result = repo.is_shared()

962

1006

self.assertEqual(

963

1007

[('call', 'Repository.is_shared', ('quack/',))],

966

1010

967

1011

def test_is_not_shared(self):

968

1012

# ('no', ) for Repository.is_shared -> 'False'.

969

responses = [(('no', ), )]

970

1013

transport_path = 'qwack'

971

repo, client = self.setup_fake_client_and_repository(

972

responses, transport_path)

1014

repo, client = self.setup_fake_client_and_repository(transport_path)

1015

client.add_success_response('no')

973

1016

result = repo.is_shared()

974

1017

self.assertEqual(

975

1018

[('call', 'Repository.is_shared', ('qwack/',))],

980

1023

class TestRepositoryLockWrite(TestRemoteRepository):

981

1024

982

1025

def test_lock_write(self):

983

responses = [(('ok', 'a token'), '')]

984

1026

transport_path = 'quack'

985

repo, client = self.setup_fake_client_and_repository(

986

responses, transport_path)

1027

repo, client = self.setup_fake_client_and_repository(transport_path)

1028

client.add_success_response('ok', 'a token')

987

1029

result = repo.lock_write()

988

1030

self.assertEqual(

989

1031

[('call', 'Repository.lock_write', ('quack/', ''))],

991

1033

self.assertEqual('a token', result)

992

1034

993

1035

def test_lock_write_already_locked(self):

994

responses = [(('LockContention', ), '')]

995

1036

transport_path = 'quack'

996

repo, client = self.setup_fake_client_and_repository(

997

responses, transport_path)

1037

repo, client = self.setup_fake_client_and_repository(transport_path)

1038

client.add_error_response('LockContention')

998

1039

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

999

1040

self.assertEqual(

1000

1041

[('call', 'Repository.lock_write', ('quack/', ''))],

1001

1042

client._calls)

1002

1043

1003

1044

def test_lock_write_unlockable(self):

1004

responses = [(('UnlockableTransport', ), '')]

1005

1045

transport_path = 'quack'

1006

repo, client = self.setup_fake_client_and_repository(

1007

responses, transport_path)

1046

repo, client = self.setup_fake_client_and_repository(transport_path)

1047

client.add_error_response('UnlockableTransport')

1008

1048

self.assertRaises(errors.UnlockableTransport, repo.lock_write)

1009

1049

self.assertEqual(

1010

1050

[('call', 'Repository.lock_write', ('quack/', ''))],

1014

1054

class TestRepositoryUnlock(TestRemoteRepository):

1015

1055

1016

1056

def test_unlock(self):

1017

responses = [(('ok', 'a token'), ''),

1018

(('ok',), '')]

1019

1057

transport_path = 'quack'

1020

repo, client = self.setup_fake_client_and_repository(

1021

responses, transport_path)

1058

repo, client = self.setup_fake_client_and_repository(transport_path)

1059

client.add_success_response('ok', 'a token')

1060

client.add_success_response('ok')

1022

1061

repo.lock_write()

1023

1062

repo.unlock()

1024

1063

self.assertEqual(

1028

1067

1029

1068

def test_unlock_wrong_token(self):

1030

1069

# If somehow the token is wrong, unlock will raise TokenMismatch.

1031

responses = [(('ok', 'a token'), ''),

1032

(('TokenMismatch',), '')]

1033

1070

transport_path = 'quack'

1034

repo, client = self.setup_fake_client_and_repository(

1035

responses, transport_path)

1071

repo, client = self.setup_fake_client_and_repository(transport_path)

1072

client.add_success_response('ok', 'a token')

1073

client.add_error_response('TokenMismatch')

1036

1074

repo.lock_write()

1037

1075

self.assertRaises(errors.TokenMismatch, repo.unlock)

1038

1076

1042

1080

def test_none(self):

1043

1081

# repo.has_revision(None) should not cause any traffic.

1044

1082

transport_path = 'quack'

1045

responses = None

1046

repo, client = self.setup_fake_client_and_repository(

1047

responses, transport_path)

1083

repo, client = self.setup_fake_client_and_repository(transport_path)

1048

1084

1049

1085

# The null revision is always there, so has_revision(None) == True.

1050

1086

self.assertEqual(True, repo.has_revision(NULL_REVISION))

1074

1110

def test_repository_tarball(self):

1075

1111

# Test that Repository.tarball generates the right operations

1076

1112

transport_path = 'repo'

1077

expected_responses = [(('ok',), self.tarball_content),

1078

]

1079

1113

expected_calls = [('call_expecting_body', 'Repository.tarball',

1080

1114

('repo/', 'bz2',),),

1081

1115

]

1082

remote_repo, client = self.setup_fake_client_and_repository(

1083

expected_responses, transport_path)

1116

repo, client = self.setup_fake_client_and_repository(transport_path)

1117

client.add_success_response_with_body(self.tarball_content, 'ok')

1084

1118

# Now actually ask for the tarball

1085

tarball_file = remote_repo._get_tarball('bz2')

1119

tarball_file = repo._get_tarball('bz2')

1086

1120

try:

1087

1121

self.assertEqual(expected_calls, client._calls)

1088

1122

self.assertEqual(self.tarball_content, tarball_file.read())

1137

1171

"""

1138

1172

record = ('bytes', [('name1',), ('name2',)])

1139

1173

pack_stream = self.make_pack_stream([record])

1140

responses = [(('ok',), pack_stream), ]

1141

1174

transport_path = 'quack'

1142

repo, client = self.setup_fake_client_and_repository(

1143

responses, transport_path)

1175

repo, client = self.setup_fake_client_and_repository(transport_path)

1176

client.add_success_response_with_body(pack_stream, 'ok')

1144

1177

search = graph.SearchResult(set(['revid']), set(), 1, set(['revid']))

1145

1178

stream = repo.get_data_stream_for_search(search)

1146

1179

self.assertRaises(errors.SmartProtocolError, list, stream)

1147

1180

1148

1181

def test_backwards_compatibility(self):

1149

1182

"""If the server doesn't recognise this request, fallback to VFS."""

1150

responses = [

1151

(('unknown verb', 'Repository.stream_revisions_chunked'), '')]

1152

repo, client = self.setup_fake_client_and_repository(

1153

responses, 'path')

1183

repo, client = self.setup_fake_client_and_repository('path')

1184

client.add_unknown_method_response(

1185

'Repository.stream_revisions_chunked')

1154

1186

self.mock_called = False

1155

1187

repo._real_repository = MockRealRepository(self)

1156

1188

search = graph.SearchResult(set(['revid']), set(), 1, set(['revid']))