~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/shelf_tests.py

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

• reverse the comparison (595 to 441)
• stop comparing with revision 441

Show diffs side-by-side

added

removed

tests/shelf_tests.py

 

1

import os.path

1

2

from bzrlib.diff import _patch_header_date

2

3

import bzrlib.tests

3

 

import os.path

4

4

 

5

5

from bzrlib.plugins.bzrtools.hunk_selector import (

6

6

    ShelveHunkSelector,

7

7

    UnshelveHunkSelector,

8

8

    )

9

9

from bzrlib.plugins.bzrtools.errors import NoColor

 

10

from bzrlib.plugins.bzrtools import cmd_shelf

 

11

 

10

12

 

11

13

class ShelfTests(bzrlib.tests.TestCaseWithTransport):

12

14

    ORIGINAL = '\n\nhello test world\n\n'

32

34

"""

33

35

    def _check_diff(self, diff=DIFF_1, filename='test_file'):

34

36

        old_tree = self.tree.basis_tree()

35

 

        old_date = _patch_header_date(old_tree, 

36

 

                                      old_tree.inventory.path2id(filename),

37

 

                                      filename)

38

 

        new_date = _patch_header_date(self.tree, 

39

 

                                      self.tree.inventory.path2id(filename),

40

 

                                      filename)

41

 

        keys = { 'filename' : filename , 'old_date': old_date, 

 

37

        old_tree.lock_read()

 

38

        self.tree.lock_read()

 

39

        try:

 

40

            old_date = _patch_header_date(old_tree,

 

41

                                          old_tree.inventory.path2id(filename),

 

42

                                          filename)

 

43

            new_date = _patch_header_date(self.tree,

 

44

                self.tree.inventory.path2id(filename), filename)

 

45

        finally:

 

46

            self.tree.unlock()

 

47

            old_tree.unlock()

 

48

        keys = { 'filename' : filename , 'old_date': old_date,

42

49

                 'new_date': new_date}

43

50

        hdr  = self.DIFF_HEADER % keys

44

51

        diff = diff % keys

45

 

        self.assertEqual(self.capture('diff', retcode=1), hdr + diff + '\n')

 

52

        self.assertEqual(self.run_bzr('diff', retcode=1)[0], hdr + diff + '\n')

46

53

 

47

54

    def _check_shelf(self, idx, diff=DIFF_1, filename='test_file',

48

55

                     new_date=None):

49

56

        old_tree = self.tree.basis_tree()

50

 

        old_date = _patch_header_date(old_tree, 

51

 

                                      old_tree.inventory.path2id(filename),

52

 

                                      filename)

 

57

        old_tree.lock_read()

 

58

        try:

 

59

            old_date = _patch_header_date(old_tree,

 

60

                                          old_tree.inventory.path2id(filename),

 

61

                                          filename)

 

62

        finally:

 

63

            old_tree.unlock()

53

64

        diff = diff % { 'filename' : filename, 'old_date': old_date,

54

65

                        'new_date': new_date}

55

66

        shelf = open(os.path.join(self.tree.basedir,

66

77

    def __test_loop(self, count):

67

78

        self.tree = self.make_branch_and_tree('.')

68

79

        self.__create_and_add_test_file()

69

 

 

70

 

        while count > 0:

71

 

            count -= 1

72

 

 

 

80

        for counter in range(count):

73

81

            # Modify the test file

74

 

            # write in binary mode because on win32 line-endings should be LF

 

82

            # write in binary mode because on win32 line-endings should be

 

83

            # LF

75

84

            f = file('test_file', 'wb')

76

85

            f.write(self.MODIFIED)

77

86

            f.close()

78

87

 

79

88

            self._check_diff()

80

 

            

81

 

            new_date = _patch_header_date(self.tree, 

82

 

                self.tree.inventory.path2id('test_file'), 'test_file')

 

89

 

 

90

            self.tree.lock_write()

 

91

            try:

 

92

                new_date = _patch_header_date(self.tree,

 

93

                    self.tree.inventory.path2id('test_file'), 'test_file')

 

94

            finally:

 

95

                self.tree.unlock()

83

96

 

84

97

            # Shelve the changes

85

 

            self.run_bzr('shelve', '--all', retcode=0)

 

98

            self.run_bzr('shelve --all', retcode=0)

86

99

 

87

100

            # Make sure there is no diff anymore

88

 

            self.assertEqual(self.capture('diff', retcode=0), '')

 

101

            self.assertEqual(self.run_bzr('diff', retcode=0)[0], '')

89

102

 

90

103

            # Make sure the file is actually back the way it was

91

104

            self.assertEqual(file('test_file').read(), self.ORIGINAL)

93

106

            self._check_shelf('00', new_date=new_date)

94

107

 

95

108

            # Unshelve

96

 

            self.run_bzr('unshelve', '--all', retcode=0)

 

109

            self.run_bzr('unshelve --all', retcode=0)

97

110

 

98

111

            self._check_diff()

99

112

 

109

122

        self.__create_and_add_test_file()

110

123

 

111

124

        # Shelve the changes

112

 

        self.run_bzr('shelve', '--all', retcode=3)

 

125

        self.run_bzr('shelve --all', retcode=3)

113

126

 

114

127

        if os.path.exists(os.path.join(self.tree.branch.base,

115

128

                '.shelf/shelves/default/00')):

133

146

        self.tree.commit(message='update test_file')

134

147

 

135

148

        # Shelve the changes

136

 

        self.run_bzr('shelve', '--all', '-r', '1', retcode=0)

 

149

        self.run_bzr('shelve --all -r 1', retcode=0)

137

150

 

138

151

        self._check_diff(self.DIFF_2)

139

152

 

141

154

        self.assertEqual(file('test_file').read(), self.ORIGINAL)

142

155

 

143

156

        # Unshelve

144

 

        self.run_bzr('unshelve', '--all', retcode=0)

 

157

        self.run_bzr('unshelve --all', retcode=0)

145

158

 

146

159

        # Make sure the file is back the way it should be

147

160

        self.assertEqual(file('test_file').read(), self.MODIFIED)

149

162

    def test_shelf_with_two_revisions(self):

150

163

        self.tree = self.make_branch_and_tree('.')

151

164

 

152

 

        cmd = 'shelve --all -r 1..2'

153

 

        (stdout, stderr) = self.run_bzr_captured(cmd.split(), retcode=None)

 

165

        stdout, stderr = self.run_bzr('shelve --all -r 1..2', retcode=None)

154

166

 

155

167

        self.assertEqual(stderr.split('\n')[0],

156

168

            'bzr: ERROR: shelve only accepts a single revision parameter.')

165

177

        self.build_tree_contents([('test_file', 'patch %s\n' % patch)])

166

178

 

167

179

        # Shelve the changes

168

 

        self.run_bzr('shelve', '--all', retcode=0)

 

180

        self.run_bzr('shelve --all', retcode=0)

169

181

 

170

182

        # Make sure there is no diff anymore

171

 

        self.assertEqual(self.capture('diff', retcode=0), '')

 

183

        self.assertEqual(self.run_bzr('diff', retcode=0)[0], '')

172

184

 

173

185

        # Check the shelf is right

174

186

        shelf = open(os.path.join(self.tree.basedir,

176

188

        self.assertTrue('patch %s' % patch in shelf)

177

189

 

178

190

        # Check the shown output is right

179

 

        shown = self.capture('shelf show %s' % patch, retcode=0)

 

191

        shown = self.run_bzr('shelf show %s' % patch, retcode=0)[0]

180

192

        self.assertEqual(shown, shelf)

181

193

 

182

194

    def test_shelf_show_multi(self):

192

204

        self.assertTrue('patch 00' in shelf)

193

205

 

194

206

        # Check the shown output is right

195

 

        shown = self.capture('shelf show 00', retcode=0)

 

207

        shown = self.run_bzr('shelf show 00', retcode=0)[0]

196

208

        self.assertEqual(shown, shelf)

197

209

 

198

210

    def test_shelf_show_unspecified(self):

208

220

        self.assertTrue('patch 02' in shelf)

209

221

 

210

222

        # Check the shown output is right

211

 

        shown = self.capture('shelf show', retcode=0)

 

223

        shown = self.run_bzr('shelf show', retcode=0)[0]

212

224

        self.assertEqual(shown, shelf)

213

225

 

214

226

    def test_shelf_show_with_no_patch(self):

215

227

        self.tree = self.make_branch_and_tree('.')

216

 

        stderr = self.run_bzr_captured(['shelf', 'show', '00'], retcode=None)[1]

 

228

        stderr = self.run_bzr('shelf show 00', retcode=None)[1]

217

229

        self.assertTrue("Patch '00' doesn't exist on shelf default!" in stderr)

218

230

 

219

231

    def test_shelf_unshelve_failure(self):

225

237

        file('test_file', 'w').write(self.MODIFIED)

226

238

 

227

239

        # Shelve the changes

228

 

        self.run_bzr('shelve', '--all', retcode=0)

 

240

        self.run_bzr('shelve --all', retcode=0)

229

241

 

230

242

        # Write an unapplyable patch into the shelf

231

243

        shelf = open(os.path.join(self.tree.basedir,

234

246

        shelf.close()

235

247

 

236

248

        # Unshelve, should fail

237

 

        self.run_bzr('unshelve', '--all', retcode=3)

 

249

        self.run_bzr('unshelve --all', retcode=3)

238

250

 

239

251

        # Make sure the patch is still there, eventhough it's broken

240

252

        shelf = open(os.path.join(self.tree.basedir,

242

254

        self.assertEqual(shelf, self.DIFF_2)

243

255

 

244

256

        # Working tree should be unchanged

245

 

        diff = self.capture('diff', retcode=0)

 

257

        diff = self.run_bzr('diff', retcode=0)[0]

246

258

        self.assertEqual(diff, '')

247

259

 

248

260

    def test_shelf_unshelve_failure_two_hunks(self):

256

268

        file('test_file2', 'w').write(self.MODIFIED)

257

269

 

258

270

        # Shelve the changes

259

 

        self.run_bzr('shelve', '--all', retcode=0)

 

271

        self.run_bzr('shelve --all', retcode=0)

260

272

 

261

273

        # Put the changes to test_file back, the shelved patch won't apply now

262

274

        file('test_file', 'w').write(self.MODIFIED)

263

275

        self.tree.commit(message='screw up test_file')

264

276

 

265

277

        # Unshelve, should fail

266

 

        self.run_bzr('unshelve', '--all', retcode=3)

 

278

        self.run_bzr('unshelve --all', retcode=3)

267

279

 

268

280

        # Working tree should be unchanged

269

 

        diff = self.capture('diff', retcode=0)

 

281

        diff = self.run_bzr('diff', retcode=0)[0]

270

282

        self.assertEqual(diff, '')

271

283

 

272

284

        # Force should succeed and modify test_file2, but leave shelf

273

 

        self.run_bzr('unshelve', '--force', '--all', retcode=0)

 

285

        self.run_bzr('unshelve --force --all', retcode=0)

274

286

        self.assertEqual(open('test_file2').read(), self.MODIFIED)

275

287

        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))

276

288

 

285

297

        file('test_file2', 'w').write(self.MODIFIED)

286

298

 

287

299

        # Shelve the changes

288

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

289

 

        self.run_bzr('shelve', '--all', 'test_file2', retcode=0)

 

300

        self.run_bzr('shelve --all test_file', retcode=0)

 

301

        self.run_bzr('shelve --all test_file2', retcode=0)

290

302

 

291

303

        # Unshelve

292

 

        self.run_bzr('unshelve', '--all', retcode=0)

 

304

        self.run_bzr('unshelve --all', retcode=0)

293

305

 

294

306

        # We should now have 00 and 01~

295

307

        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))

296

308

        self.assertTrue(os.path.exists('.shelf/shelves/default/01~'))

297

309

 

298

310

        # Check ls works

299

 

        lines = self.capture('shelf ls', retcode=0).split('\n')

 

311

        lines = self.run_bzr('shelf ls', retcode=0)[0].split('\n')

300

312

        for line in lines:

301

313

            self.assertFalse(line.startswith(' 01'))

302

314

 

303

315

        # Unshelve, if unshelve is confused by the backup it will fail

304

 

        self.run_bzr('unshelve', '--all', retcode=0)

 

316

        self.run_bzr('unshelve --all', retcode=0)

305

317

 

306

318

    def test_shelf_delete(self):

307

319

        self.tree = self.make_branch_and_tree('.')

308

 

 

309

 

        self.__create_and_add_test_file()

310

 

        self.__create_and_add_test_file(filename='test_file2')

311

 

 

312

 

        # Modify the test files

313

 

        # write in binary mode because on win32 line-endings should be LF

314

 

        f = file('test_file', 'wb')

315

 

        f.write(self.MODIFIED)

316

 

        f.close()

317

 

        f = file('test_file2', 'wb')

318

 

        f.write(self.MODIFIED)

319

 

        f.close()

320

 

        new_date = _patch_header_date(self.tree, 

321

 

            self.tree.inventory.path2id('test_file'), 'test_file')

 

320

        self.tree.lock_write()

 

321

        try:

 

322

            self.__create_and_add_test_file()

 

323

            self.__create_and_add_test_file(filename='test_file2')

 

324

 

 

325

            # Modify the test files

 

326

            # write in binary mode because on win32 line-endings should be LF

 

327

            f = file('test_file', 'wb')

 

328

            f.write(self.MODIFIED)

 

329

            f.close()

 

330

            f = file('test_file2', 'wb')

 

331

            f.write(self.MODIFIED)

 

332

            f.close()

 

333

            new_date = _patch_header_date(self.tree,

 

334

                self.tree.inventory.path2id('test_file'), 'test_file')

 

335

        finally:

 

336

            self.tree.unlock()

322

337

 

323

338

        # Shelve the changes

324

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

325

 

        self.run_bzr('shelve', '--all', 'test_file2', retcode=0)

 

339

        self.run_bzr('shelve --all test_file', retcode=0)

 

340

        self.run_bzr('shelve --all test_file2', retcode=0)

326

341

 

327

342

        self._check_shelf('00', new_date=new_date)

328

343

 

329

344

        # Delete 00

330

 

        self.run_bzr('shelf', 'delete', '00', retcode=0)

 

345

        self.run_bzr('shelf delete 00', retcode=0)

331

346

 

332

347

        # We should now have 01 but not 00, but we should have 00~

333

348

        self.assertFalse(os.path.exists('.shelf/shelves/default/00'))

338

353

        self._check_shelf('00~', new_date=new_date)

339

354

 

340

355

        # Check ls works

341

 

        lines = self.capture('shelf ls', retcode=0).split('\n')

 

356

        lines = self.run_bzr('shelf ls', retcode=0)[0].split('\n')

342

357

        for line in lines:

343

358

            self.assertFalse(line.startswith(' 00'))

344

359

 

345

360

        # Unshelve should unshelve 01

346

 

        self.run_bzr('unshelve', '--all', retcode=0)

 

361

        self.run_bzr('unshelve --all', retcode=0)

347

362

        self.assertEqual(file('test_file2').read(), self.MODIFIED)

348

363

 

349

364

    def test_shelf_gaps(self):

350

365

        self.tree = self.make_branch_and_tree('.')

351

366

        self.__create_and_add_test_file()

352

367

        file('test_file', 'w').write(self.MODIFIED)

353

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

 

368

        self.run_bzr('shelve --all test_file', retcode=0)

354

369

        file('test_file', 'w').write(self.MODIFIED)

355

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

 

370

        self.run_bzr('shelve --all test_file', retcode=0)

356

371

 

357

372

        # Now delete 00, leaving 01, next shelve should go into 02

358

 

        self.run_bzr('shelf', 'delete', '0', retcode=0)

 

373

        self.run_bzr('shelf delete 0', retcode=0)

359

374

        self.assertFalse(os.path.exists('.shelf/shelves/default/00'))

360

375

        self.assertFalse(os.path.exists('.shelf/shelves/default/02'))

361

376

        file('test_file', 'w').write(self.MODIFIED)

362

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

 

377

        self.run_bzr('shelve --all test_file', retcode=0)

363

378

        self.assertFalse(os.path.exists('.shelf/shelves/default/00'))

364

379

        self.assertTrue(os.path.exists('.shelf/shelves/default/02'))

365

380

 

370

385

 

371

386

        # Modify then shelve, so we're not upgrading to 00, just for kicks

372

387

        file('test_file', 'w').write(self.MODIFIED)

373

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

 

388

        self.run_bzr('shelve --all test_file', retcode=0)

374

389

 

375

390

        open('.bzr-shelf', 'w').write('First old shelf')

376

391

        open('.bzr-shelf-1', 'w').write('Second old shelf')

378

393

 

379

394

        # shelve and unshelve should bitch and do nothing

380

395

        file('test_file', 'w').write('blah blah blah')

381

 

        self.run_bzr('shelve', '--all', retcode=3)

 

396

        self.run_bzr('shelve --all', retcode=3)

382

397

        self.assertFalse(os.path.exists('.shelf/shelves/default/01'))

383

398

        self.assertEqual(file('test_file').read(), 'blah blah blah')

384

 

        self.run_bzr('unshelve', '--all', retcode=3)

 

399

        self.run_bzr('unshelve --all', retcode=3)

385

400

        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))

386

401

 

387

402

        # Upgrade, make sure it worked

388

 

        self.run_bzr('shelf', 'upgrade', retcode=0)

 

403

        self.run_bzr('shelf upgrade', retcode=0)

389

404

        self.assertEqual(open('.shelf/shelves/default/01').read(),

390

405

                'First old shelf')

391

406

        self.assertEqual(open('.shelf/shelves/default/02').read(),

402

417

        self.assertFalse(os.path.exists('.bzr-shelf-3'))

403

418

 

404

419

        # Shelve should work now

405

 

        self.run_bzr('shelve', '--all', retcode=0)

 

420

        self.run_bzr('shelve --all', retcode=0)

406

421

 

407

422

    def test_shelf_p1_patch(self):

408

423

        self.tree = self.make_branch_and_tree('.')

410

425

        self.__create_and_add_test_file()

411

426

 

412

427

        # Run a benign shelf command to setup .shelf for us

413

 

        self.run_bzr('shelf', 'ls', retcode=0)

 

428

        self.run_bzr('shelf ls', retcode=0)

414

429

 

415

430

        old_tree = self.tree.basis_tree()

416

 

        old_date = _patch_header_date(old_tree, 

417

 

                                      old_tree.inventory.path2id('test_file'),

418

 

                                      'test_file')

419

 

        new_date = _patch_header_date(self.tree, 

420

 

                                      self.tree.inventory.path2id('test_file'),

421

 

                                      'test_file')

 

431

        old_tree.lock_read()

 

432

        self.tree.lock_read()

 

433

        try:

 

434

            old_date = _patch_header_date(old_tree,

 

435

                old_tree.inventory.path2id('test_file'),

 

436

                                          'test_file')

 

437

            new_date = _patch_header_date(self.tree,

 

438

                self.tree.inventory.path2id('test_file'), 'test_file')

 

439

        finally:

 

440

            old_tree.unlock()

 

441

            self.tree.unlock()

422

442

        # Fake a -p0 shelved patch

423

443

        diff = self.DIFF_1 % { 'filename' : 'test_file', 'old_date': old_date,

424

444

                               'new_date' : new_date}

427

447

        open('.shelf/shelves/default/00', 'w').write(diff)

428

448

 

429

449

        # This should work

430

 

        self.run_bzr('unshelve', '--all', retcode=0)

 

450

        self.run_bzr('unshelve --all', retcode=0)

431

451

 

432

452

        self._check_diff()

433

453

 

448

468

        f.close()

449

469

 

450

470

        # Shelve the changes

451

 

        self.run_bzr('shelve', '--all', retcode=0)

 

471

        self.run_bzr('shelve --all', retcode=0)

452

472

 

453

473

        # Working tree should be unchanged

454

 

        diff = self.capture('diff', retcode=0)

 

474

        diff = self.run_bzr('diff', retcode=0)[0]

455

475

        self.assertEqual(diff, '')

456

476

 

457

477

        # Unshelve, should succeed

458

 

        self.run_bzr('unshelve', '--all', retcode=0)

 

478

        self.run_bzr('unshelve --all', retcode=0)

459

479

 

460

480

        self._check_diff(filename='subdir/test_file')

461

481

 

462

482

        # Make sure relative filenames work ok

463

 

        self.run_bzr('shelve', 'test_file', '--all', retcode=0)

 

483

        self.run_bzr('shelve test_file --all', retcode=0)

464

484

 

465

485

    def test_shelf_shelf_bogus_subcommand(self):

466

486

        self.tree = self.make_branch_and_tree('.')

467

 

        self.run_bzr('shelf', 'foo', retcode=3) # <- retcode == 3

 

487

        self.run_bzr('shelf foo', retcode=3) # <- retcode == 3

468

488

 

469

489

    def test_shelf_OOO_unshelve(self):

470

490

        self.tree = self.make_branch_and_tree('.')

478

498

 

479

499

        # Shelve the changes

480

500

        for i in range(1, 5):

481

 

            self.run_bzr('shelve', '--all', 'test_file%d' % i, retcode=0)

 

501

            self.run_bzr(['shelve', '--all', 'test_file%d' % i], retcode=0)

482

502

 

483

503

        # Check shelving worked

484

504

        for i in range(1, 5):

489

509

            self.assertTrue(os.path.exists('.shelf/shelves/default/0%d' % i))

490

510

 

491

511

        # Unshelve 00

492

 

        self.run_bzr('unshelve', '--all', '00', retcode=0)

 

512

        self.run_bzr('unshelve --all 00', retcode=0)

493

513

        self.assertEqual(file('test_file1').read(), self.MODIFIED)

494

514

 

495

515

        # Check ls works

496

 

        lines = self.capture('shelf ls', retcode=0).split('\n')

 

516

        lines = self.run_bzr('shelf ls', retcode=0)[0].split('\n')

497

517

        for line in lines:

498

518

            self.assertFalse(line.startswith(' 00'))

499

519

 

500

520

        # Check we can reshelve once we've unshelved out of order, should be 04

501

521

        self.assertFalse(os.path.exists('.shelf/shelves/default/04'))

502

 

        self.run_bzr('shelve', '--all')

 

522

        self.run_bzr('shelve --all')

503

523

        self.assertTrue(os.path.exists('.shelf/shelves/default/04'))

504

524

 

505

525

        # Check ls works

506

 

        text = self.capture('shelf ls', retcode=0)

 

526

        text = self.run_bzr('shelf ls', retcode=0)[0]

507

527

        for line in text.split('\n'):

508

528

            self.assertFalse(line.startswith(' 00'))

509

529

 

510

530

        # We now have 01,02,03,04

511

531

        # Unshelve 02

512

 

        self.run_bzr('unshelve', '--all', '02', retcode=0)

 

532

        self.run_bzr('unshelve --all 02', retcode=0)

513

533

        self.assertEqual(file('test_file3').read(), self.MODIFIED)

514

534

 

515

535

        # Unshelve the default, this is the reshelved 00, hence modifies file 1

516

 

        self.run_bzr('unshelve', '--all', retcode=0)

 

536

        self.run_bzr('unshelve --all', retcode=0)

517

537

        self.assertEqual(file('test_file1').read(), self.MODIFIED)

518

538

 

519

539

    def test_shelf_switch_basic(self):

522

542

 

523

543

        # This should go to "default"

524

544

        file('test_file', 'w').write(self.MODIFIED)

525

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

 

545

        self.run_bzr('shelve --all test_file', retcode=0)

526

546

 

527

547

        # Switch to "other"

528

 

        self.run_bzr('shelf', 'switch', 'other', retcode=0)

 

548

        self.run_bzr('shelf switch other', retcode=0)

529

549

        file('test_file', 'w').write(self.MODIFIED)

530

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

 

550

        self.run_bzr('shelve --all test_file', retcode=0)

531

551

 

532

552

        # Check it worked

533

553

        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))

535

555

        self.assertTrue(os.path.exists('.shelf/shelves/other/00'))

536

556

 

537

557

        # Switch back

538

 

        self.run_bzr('shelf', 'switch', 'default', retcode=0)

 

558

        self.run_bzr('shelf switch default', retcode=0)

539

559

        file('test_file', 'w').write(self.MODIFIED)

540

 

        self.run_bzr('shelve', '--all', 'test_file', retcode=0)

 

560

        self.run_bzr('shelve --all test_file', retcode=0)

541

561

 

542

562

        # Check that worked

543

563

        self.assertTrue(os.path.exists('.shelf/shelves/default/01'))

544

564

        self.assertFalse(os.path.exists('.shelf/shelves/other/01'))

545

565

 

 

566

    def test_shelf_binary(self):

 

567

        self.tree = self.make_branch_and_tree('.')

 

568

        self.build_tree_contents([('file', '\x00')])

 

569

        self.tree.add('file')

 

570

        self.run_bzr_error(['Changes involve binary files.'], 'shelve --all')

 

571

 

546

572

    def test_shelf_bad_patch_arg(self):

547

573

        self.tree = self.make_branch_and_tree('.')

548

574

 

549

575

        # Check the bad arg handling

550

 

        stdout, error = self.run_bzr_captured(['unshelve', '01'], retcode=3)

 

576

        stdout, error = self.run_bzr('unshelve 01', retcode=3)

551

577

        self.assertTrue("Patch '01' doesn't exist on shelf" in error)

552

578

 

553

 

        stdout, error = self.run_bzr_captured(['unshelve', 'foo'], retcode=3)

 

579

        stdout, error = self.run_bzr('unshelve foo', retcode=3)

554

580

        self.assertTrue("Invalid patch name 'foo'" in error)

555

581

 

556

582

        # Hex and is cracky, so it shouldn't work

557

 

        stdout, error = self.run_bzr_captured(['unshelve', '0x00'], retcode=3)

 

583

        stdout, error = self.run_bzr(['unshelve', '0x00'], retcode=3)

558

584

        self.assertTrue("Invalid patch name '0x00'" in error)

559

585

 

560

586

    def test_color_hunk_selector(self):

561

587

        """Make sure NoColor is raised iff terminal.has_ansi_colors is False"""

562

588

        hs = ShelveHunkSelector([])

563

589

        hs = UnshelveHunkSelector([])

564

 

        from bzrlib.plugins.bzrtools import terminal

 

590

        try:

 

591

            from bzrlib.plugins.bzrtools import terminal

 

592

        except ImportError:

 

593

            from bzrtools import terminal

565

594

        old_has_ansi_colors = terminal.has_ansi_colors

566

595

        terminal.has_ansi_colors = lambda: False

567

596

        try:

589

618

        f = file('test_file', 'wb')

590

619

        f.write(self.MODIFIED)

591

620

        f.close()

592

 

        stdout, error = self.run_bzr_captured(['shelve', '--all', 

593

 

                                               '--no-color'])

594

 

        stdout, error = self.run_bzr_captured(['unshelve', '--all', 

595

 

                                               '--no-color'])

 

621

        stdout, error = self.run_bzr('shelve --all --no-color')

 

622

        stdout, error = self.run_bzr('unshelve --all --no-color')

 

623

 

 

624

    def test_shelf_help(self):

 

625

        self.assertContainsRe(cmd_shelf().help(),

 

626

                              'list\n.*List the patches on the current shelf')

• Older »

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