~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/shelf_tests.py

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

• reverse the comparison (423.1.1 to 650)
• stop comparing with revision 650

Show diffs side-by-side

added

removed

tests/shelf_tests.py

1

 

import os.path

2

1

from bzrlib.diff import _patch_header_date

3

2

import bzrlib.tests

4

 

 

5

 

from bzrlib.plugins.bzrtools.hunk_selector import (

6

 

    ShelveHunkSelector,

7

 

    UnshelveHunkSelector,

8

 

    )

9

 

from bzrlib.plugins.bzrtools.errors import NoColor

10

 

from bzrlib.plugins.bzrtools import cmd_shelf

11

 

 

 

3

import os.path

12

4

 

13

5

class ShelfTests(bzrlib.tests.TestCaseWithTransport):

14

6

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

34

26

"""

35

27

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

36

28

        old_tree = self.tree.basis_tree()

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,

 

29

        old_date = _patch_header_date(old_tree, 

 

30

                                      old_tree.inventory.path2id(filename),

 

31

                                      filename)

 

32

        new_date = _patch_header_date(self.tree, 

 

33

                                      self.tree.inventory.path2id(filename),

 

34

                                      filename)

 

35

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

49

36

                 'new_date': new_date}

50

37

        hdr  = self.DIFF_HEADER % keys

51

38

        diff = diff % keys

52

 

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

 

39

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

53

40

 

54

41

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

55

42

                     new_date=None):

56

43

        old_tree = self.tree.basis_tree()

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()

 

44

        old_date = _patch_header_date(old_tree, 

 

45

                                      old_tree.inventory.path2id(filename),

 

46

                                      filename)

64

47

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

65

48

                        'new_date': new_date}

66

49

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

77

60

    def __test_loop(self, count):

78

61

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

79

62

        self.__create_and_add_test_file()

80

 

        for counter in range(count):

 

63

 

 

64

        while count > 0:

 

65

            count -= 1

 

66

 

81

67

            # Modify the test file

82

 

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

83

 

            # LF

 

68

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

84

69

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

85

70

            f.write(self.MODIFIED)

86

71

            f.close()

87

72

 

88

73

            self._check_diff()

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()

 

74

            

 

75

            new_date = _patch_header_date(self.tree, 

 

76

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

96

77

 

97

78

            # Shelve the changes

98

 

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

 

79

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

99

80

 

100

81

            # Make sure there is no diff anymore

101

 

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

 

82

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

102

83

 

103

84

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

104

85

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

106

87

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

107

88

 

108

89

            # Unshelve

109

 

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

 

90

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

110

91

 

111

92

            self._check_diff()

112

93

 

122

103

        self.__create_and_add_test_file()

123

104

 

124

105

        # Shelve the changes

125

 

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

 

106

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

126

107

 

127

108

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

128

109

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

146

127

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

147

128

 

148

129

        # Shelve the changes

149

 

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

 

130

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

150

131

 

151

132

        self._check_diff(self.DIFF_2)

152

133

 

154

135

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

155

136

 

156

137

        # Unshelve

157

 

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

 

138

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

158

139

 

159

140

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

160

141

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

162

143

    def test_shelf_with_two_revisions(self):

163

144

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

164

145

 

165

 

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

 

146

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

 

147

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

166

148

 

167

149

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

168

150

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

177

159

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

178

160

 

179

161

        # Shelve the changes

180

 

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

 

162

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

181

163

 

182

164

        # Make sure there is no diff anymore

183

 

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

 

165

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

184

166

 

185

167

        # Check the shelf is right

186

168

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

188

170

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

189

171

 

190

172

        # Check the shown output is right

191

 

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

 

173

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

192

174

        self.assertEqual(shown, shelf)

193

175

 

194

176

    def test_shelf_show_multi(self):

204

186

        self.assertTrue('patch 00' in shelf)

205

187

 

206

188

        # Check the shown output is right

207

 

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

 

189

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

208

190

        self.assertEqual(shown, shelf)

209

191

 

210

192

    def test_shelf_show_unspecified(self):

220

202

        self.assertTrue('patch 02' in shelf)

221

203

 

222

204

        # Check the shown output is right

223

 

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

 

205

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

224

206

        self.assertEqual(shown, shelf)

225

207

 

226

208

    def test_shelf_show_with_no_patch(self):

227

209

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

228

 

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

 

210

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

229

211

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

230

212

 

231

213

    def test_shelf_unshelve_failure(self):

237

219

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

238

220

 

239

221

        # Shelve the changes

240

 

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

 

222

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

241

223

 

242

224

        # Write an unapplyable patch into the shelf

243

225

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

246

228

        shelf.close()

247

229

 

248

230

        # Unshelve, should fail

249

 

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

 

231

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

250

232

 

251

233

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

252

234

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

254

236

        self.assertEqual(shelf, self.DIFF_2)

255

237

 

256

238

        # Working tree should be unchanged

257

 

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

 

239

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

258

240

        self.assertEqual(diff, '')

259

241

 

260

242

    def test_shelf_unshelve_failure_two_hunks(self):

268

250

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

269

251

 

270

252

        # Shelve the changes

271

 

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

 

253

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

272

254

 

273

255

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

274

256

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

275

257

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

276

258

 

277

259

        # Unshelve, should fail

278

 

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

 

260

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

279

261

 

280

262

        # Working tree should be unchanged

281

 

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

 

263

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

282

264

        self.assertEqual(diff, '')

283

265

 

284

266

        # Force should succeed and modify test_file2, but leave shelf

285

 

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

 

267

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

286

268

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

287

269

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

288

270

 

297

279

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

298

280

 

299

281

        # Shelve the changes

300

 

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

301

 

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

 

282

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

 

283

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

302

284

 

303

285

        # Unshelve

304

 

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

 

286

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

305

287

 

306

288

        # We should now have 00 and 01~

307

289

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

308

290

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

309

291

 

310

292

        # Check ls works

311

 

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

 

293

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

312

294

        for line in lines:

313

295

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

314

296

 

315

297

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

316

 

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

 

298

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

317

299

 

318

300

    def test_shelf_delete(self):

319

301

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

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()

 

302

 

 

303

        self.__create_and_add_test_file()

 

304

        self.__create_and_add_test_file(filename='test_file2')

 

305

 

 

306

        # Modify the test files

 

307

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

 

308

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

 

309

        f.write(self.MODIFIED)

 

310

        f.close()

 

311

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

 

312

        f.write(self.MODIFIED)

 

313

        f.close()

 

314

        new_date = _patch_header_date(self.tree, 

 

315

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

337

316

 

338

317

        # Shelve the changes

339

 

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

340

 

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

 

318

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

 

319

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

341

320

 

342

321

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

343

322

 

344

323

        # Delete 00

345

 

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

 

324

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

346

325

 

347

326

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

348

327

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

353

332

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

354

333

 

355

334

        # Check ls works

356

 

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

 

335

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

357

336

        for line in lines:

358

337

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

359

338

 

360

339

        # Unshelve should unshelve 01

361

 

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

 

340

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

362

341

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

363

342

 

364

343

    def test_shelf_gaps(self):

365

344

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

366

345

        self.__create_and_add_test_file()

367

346

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

368

 

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

 

347

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

369

348

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

370

 

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

 

349

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

371

350

 

372

351

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

373

 

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

 

352

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

374

353

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

375

354

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

376

355

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

377

 

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

 

356

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

378

357

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

379

358

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

380

359

 

385

364

 

386

365

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

387

366

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

388

 

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

 

367

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

389

368

 

390

369

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

391

370

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

393

372

 

394

373

        # shelve and unshelve should bitch and do nothing

395

374

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

396

 

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

 

375

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

397

376

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

398

377

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

399

 

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

 

378

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

400

379

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

401

380

 

402

381

        # Upgrade, make sure it worked

403

 

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

 

382

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

404

383

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

405

384

                'First old shelf')

406

385

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

417

396

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

418

397

 

419

398

        # Shelve should work now

420

 

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

 

399

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

421

400

 

422

401

    def test_shelf_p1_patch(self):

423

402

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

425

404

        self.__create_and_add_test_file()

426

405

 

427

406

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

428

 

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

 

407

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

429

408

 

430

409

        old_tree = self.tree.basis_tree()

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()

 

410

        old_date = _patch_header_date(old_tree, 

 

411

                                      old_tree.inventory.path2id('test_file'),

 

412

                                      'test_file')

 

413

        new_date = _patch_header_date(self.tree, 

 

414

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

 

415

                                      'test_file')

442

416

        # Fake a -p0 shelved patch

443

417

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

444

418

                               'new_date' : new_date}

447

421

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

448

422

 

449

423

        # This should work

450

 

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

 

424

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

451

425

 

452

426

        self._check_diff()

453

427

 

468

442

        f.close()

469

443

 

470

444

        # Shelve the changes

471

 

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

 

445

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

472

446

 

473

447

        # Working tree should be unchanged

474

 

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

 

448

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

475

449

        self.assertEqual(diff, '')

476

450

 

477

451

        # Unshelve, should succeed

478

 

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

 

452

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

479

453

 

480

454

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

481

455

 

482

456

        # Make sure relative filenames work ok

483

 

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

 

457

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

484

458

 

485

459

    def test_shelf_shelf_bogus_subcommand(self):

486

460

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

487

 

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

 

461

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

488

462

 

489

463

    def test_shelf_OOO_unshelve(self):

490

464

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

498

472

 

499

473

        # Shelve the changes

500

474

        for i in range(1, 5):

501

 

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

 

475

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

502

476

 

503

477

        # Check shelving worked

504

478

        for i in range(1, 5):

509

483

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

510

484

 

511

485

        # Unshelve 00

512

 

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

 

486

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

513

487

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

514

488

 

515

489

        # Check ls works

516

 

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

 

490

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

517

491

        for line in lines:

518

492

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

519

493

 

520

494

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

521

495

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

522

 

        self.run_bzr('shelve --all')

 

496

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

523

497

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

524

498

 

525

499

        # Check ls works

526

 

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

 

500

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

527

501

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

528

502

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

529

503

 

530

504

        # We now have 01,02,03,04

531

505

        # Unshelve 02

532

 

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

 

506

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

533

507

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

534

508

 

535

509

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

536

 

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

 

510

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

537

511

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

538

512

 

539

513

    def test_shelf_switch_basic(self):

542

516

 

543

517

        # This should go to "default"

544

518

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

545

 

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

 

519

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

546

520

 

547

521

        # Switch to "other"

548

 

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

 

522

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

549

523

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

550

 

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

 

524

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

551

525

 

552

526

        # Check it worked

553

527

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

555

529

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

556

530

 

557

531

        # Switch back

558

 

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

 

532

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

559

533

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

560

 

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

 

534

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

561

535

 

562

536

        # Check that worked

563

537

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

564

538

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

565

539

 

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

 

 

572

540

    def test_shelf_bad_patch_arg(self):

573

541

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

574

542

 

575

543

        # Check the bad arg handling

576

 

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

 

544

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

577

545

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

578

546

 

579

 

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

 

547

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

580

548

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

581

549

 

582

550

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

583

 

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

 

551

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

584

552

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

585

 

 

586

 

    def test_color_hunk_selector(self):

587

 

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

588

 

        hs = ShelveHunkSelector([])

589

 

        hs = UnshelveHunkSelector([])

590

 

        try:

591

 

            from bzrlib.plugins.bzrtools import terminal

592

 

        except ImportError:

593

 

            from bzrtools import terminal

594

 

        old_has_ansi_colors = terminal.has_ansi_colors

595

 

        terminal.has_ansi_colors = lambda: False

596

 

        try:

597

 

            self.assertRaises(NoColor, ShelveHunkSelector, [], True)

598

 

            self.assertRaises(NoColor, UnshelveHunkSelector, [], True)

599

 

            terminal.has_ansi_colors = lambda: True

600

 

            hs = ShelveHunkSelector([], color=True)

601

 

            hs = UnshelveHunkSelector([], color=True)

602

 

        finally:

603

 

            terminal.has_ansi_colors = old_has_ansi_colors

604

 

 

605

 

    def test_no_color(self):

606

 

        """Ensure --no-color switch can be passed"""

607

 

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

608

 

 

609

 

        subdir = 'subdir'

610

 

        os.mkdir(subdir)

611

 

        self.tree.add(subdir)

612

 

        os.chdir(subdir)

613

 

 

614

 

        self.__create_and_add_test_file()

615

 

 

616

 

        # Modify the test file

617

 

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

618

 

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

619

 

        f.write(self.MODIFIED)

620

 

        f.close()

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')

627

 

 

628

 

    def test_show_empty_shelf(self):

629

 

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

630

 

        self.run_bzr_error(('No patches on shelf.',), 'shelf show')

• Older »

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