~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/shelf_tests.py

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

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

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

 

 

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 command

 

11

from bzrlib.plugins.bzrtools.command_classes import cmd_shelf1

 

12

 

4

13

 

5

14

class ShelfTests(bzrlib.tests.TestCaseWithTransport):

6

15

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

24

33

+hello test world

25

34

 

26

35

"""

 

36

    def setUp(self):

 

37

        bzrlib.tests.TestCaseWithTransport.setUp(self)

 

38

        command._testing = True

 

39

        self.addCleanup(command._stop_testing)

 

40

 

27

41

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

28

42

        old_tree = self.tree.basis_tree()

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, 

 

43

        old_tree.lock_read()

 

44

        self.tree.lock_read()

 

45

        try:

 

46

            old_date = _patch_header_date(old_tree,

 

47

                                          old_tree.path2id(filename),

 

48

                                          filename)

 

49

            new_date = _patch_header_date(self.tree,

 

50

                self.tree.path2id(filename), filename)

 

51

        finally:

 

52

            self.tree.unlock()

 

53

            old_tree.unlock()

 

54

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

36

55

                 'new_date': new_date}

37

56

        hdr  = self.DIFF_HEADER % keys

38

57

        diff = diff % keys

39

 

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

 

58

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

40

59

 

41

60

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

42

61

                     new_date=None):

43

62

        old_tree = self.tree.basis_tree()

44

 

        old_date = _patch_header_date(old_tree, 

45

 

                                      old_tree.inventory.path2id(filename),

46

 

                                      filename)

 

63

        old_tree.lock_read()

 

64

        try:

 

65

            old_date = _patch_header_date(old_tree,

 

66

                                          old_tree.path2id(filename),

 

67

                                          filename)

 

68

        finally:

 

69

            old_tree.unlock()

47

70

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

48

71

                        'new_date': new_date}

49

72

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

60

83

    def __test_loop(self, count):

61

84

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

62

85

        self.__create_and_add_test_file()

63

 

 

64

 

        while count > 0:

65

 

            count -= 1

66

 

 

 

86

        for counter in range(count):

67

87

            # Modify the test file

68

 

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

 

88

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

 

89

            # LF

69

90

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

70

91

            f.write(self.MODIFIED)

71

92

            f.close()

72

93

 

73

94

            self._check_diff()

74

 

            

75

 

            new_date = _patch_header_date(self.tree, 

76

 

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

 

95

 

 

96

            self.tree.lock_write()

 

97

            try:

 

98

                new_date = _patch_header_date(self.tree,

 

99

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

 

100

            finally:

 

101

                self.tree.unlock()

77

102

 

78

103

            # Shelve the changes

79

 

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

 

104

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

80

105

 

81

106

            # Make sure there is no diff anymore

82

 

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

 

107

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

83

108

 

84

109

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

85

110

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

87

112

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

88

113

 

89

114

            # Unshelve

90

 

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

 

115

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

91

116

 

92

117

            self._check_diff()

93

118

 

103

128

        self.__create_and_add_test_file()

104

129

 

105

130

        # Shelve the changes

106

 

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

 

131

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

107

132

 

108

133

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

109

134

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

127

152

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

128

153

 

129

154

        # Shelve the changes

130

 

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

 

155

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

131

156

 

132

157

        self._check_diff(self.DIFF_2)

133

158

 

135

160

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

136

161

 

137

162

        # Unshelve

138

 

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

 

163

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

139

164

 

140

165

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

141

166

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

143

168

    def test_shelf_with_two_revisions(self):

144

169

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

145

170

 

146

 

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

147

 

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

 

171

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

148

172

 

149

173

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

150

174

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

159

183

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

160

184

 

161

185

        # Shelve the changes

162

 

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

 

186

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

163

187

 

164

188

        # Make sure there is no diff anymore

165

 

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

 

189

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

166

190

 

167

191

        # Check the shelf is right

168

192

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

170

194

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

171

195

 

172

196

        # Check the shown output is right

173

 

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

 

197

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

174

198

        self.assertEqual(shown, shelf)

175

199

 

176

200

    def test_shelf_show_multi(self):

186

210

        self.assertTrue('patch 00' in shelf)

187

211

 

188

212

        # Check the shown output is right

189

 

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

 

213

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

190

214

        self.assertEqual(shown, shelf)

191

215

 

192

216

    def test_shelf_show_unspecified(self):

202

226

        self.assertTrue('patch 02' in shelf)

203

227

 

204

228

        # Check the shown output is right

205

 

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

 

229

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

206

230

        self.assertEqual(shown, shelf)

207

231

 

208

232

    def test_shelf_show_with_no_patch(self):

209

233

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

210

 

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

 

234

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

211

235

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

212

236

 

213

237

    def test_shelf_unshelve_failure(self):

219

243

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

220

244

 

221

245

        # Shelve the changes

222

 

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

 

246

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

223

247

 

224

248

        # Write an unapplyable patch into the shelf

225

249

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

228

252

        shelf.close()

229

253

 

230

254

        # Unshelve, should fail

231

 

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

 

255

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

232

256

 

233

257

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

234

258

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

236

260

        self.assertEqual(shelf, self.DIFF_2)

237

261

 

238

262

        # Working tree should be unchanged

239

 

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

 

263

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

240

264

        self.assertEqual(diff, '')

241

265

 

242

266

    def test_shelf_unshelve_failure_two_hunks(self):

250

274

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

251

275

 

252

276

        # Shelve the changes

253

 

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

 

277

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

254

278

 

255

279

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

256

280

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

257

281

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

258

282

 

259

283

        # Unshelve, should fail

260

 

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

 

284

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

261

285

 

262

286

        # Working tree should be unchanged

263

 

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

 

287

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

264

288

        self.assertEqual(diff, '')

265

289

 

266

290

        # Force should succeed and modify test_file2, but leave shelf

267

 

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

 

291

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

268

292

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

269

293

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

270

294

 

279

303

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

280

304

 

281

305

        # Shelve the changes

282

 

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

283

 

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

 

306

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

 

307

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

284

308

 

285

309

        # Unshelve

286

 

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

 

310

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

287

311

 

288

312

        # We should now have 00 and 01~

289

313

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

290

314

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

291

315

 

292

316

        # Check ls works

293

 

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

 

317

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

294

318

        for line in lines:

295

319

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

296

320

 

297

321

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

298

 

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

 

322

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

299

323

 

300

324

    def test_shelf_delete(self):

301

325

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

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

 

326

        self.tree.lock_write()

 

327

        try:

 

328

            self.__create_and_add_test_file()

 

329

            self.__create_and_add_test_file(filename='test_file2')

 

330

 

 

331

            # Modify the test files

 

332

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

 

333

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

 

334

            f.write(self.MODIFIED)

 

335

            f.close()

 

336

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

 

337

            f.write(self.MODIFIED)

 

338

            f.close()

 

339

            new_date = _patch_header_date(self.tree,

 

340

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

 

341

        finally:

 

342

            self.tree.unlock()

316

343

 

317

344

        # Shelve the changes

318

 

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

319

 

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

 

345

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

 

346

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

320

347

 

321

348

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

322

349

 

323

350

        # Delete 00

324

 

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

 

351

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

325

352

 

326

353

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

327

354

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

332

359

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

333

360

 

334

361

        # Check ls works

335

 

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

 

362

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

336

363

        for line in lines:

337

364

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

338

365

 

339

366

        # Unshelve should unshelve 01

340

 

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

 

367

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

341

368

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

342

369

 

343

370

    def test_shelf_gaps(self):

344

371

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

345

372

        self.__create_and_add_test_file()

346

373

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

347

 

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

 

374

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

348

375

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

349

 

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

 

376

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

350

377

 

351

378

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

352

 

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

 

379

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

353

380

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

354

381

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

355

382

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

356

 

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

 

383

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

357

384

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

358

385

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

359

386

 

364

391

 

365

392

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

366

393

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

367

 

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

 

394

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

368

395

 

369

396

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

370

397

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

372

399

 

373

400

        # shelve and unshelve should bitch and do nothing

374

401

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

375

 

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

 

402

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

376

403

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

377

404

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

378

 

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

 

405

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

379

406

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

380

407

 

381

408

        # Upgrade, make sure it worked

382

 

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

 

409

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

383

410

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

384

411

                'First old shelf')

385

412

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

396

423

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

397

424

 

398

425

        # Shelve should work now

399

 

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

 

426

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

400

427

 

401

428

    def test_shelf_p1_patch(self):

402

429

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

404

431

        self.__create_and_add_test_file()

405

432

 

406

433

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

407

 

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

 

434

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

408

435

 

409

436

        old_tree = self.tree.basis_tree()

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

 

437

        old_tree.lock_read()

 

438

        self.tree.lock_read()

 

439

        try:

 

440

            old_date = _patch_header_date(old_tree,

 

441

                old_tree.path2id('test_file'),

 

442

                                          'test_file')

 

443

            new_date = _patch_header_date(self.tree,

 

444

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

 

445

        finally:

 

446

            old_tree.unlock()

 

447

            self.tree.unlock()

416

448

        # Fake a -p0 shelved patch

417

449

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

418

450

                               'new_date' : new_date}

421

453

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

422

454

 

423

455

        # This should work

424

 

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

 

456

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

425

457

 

426

458

        self._check_diff()

427

459

 

442

474

        f.close()

443

475

 

444

476

        # Shelve the changes

445

 

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

 

477

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

446

478

 

447

479

        # Working tree should be unchanged

448

 

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

 

480

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

449

481

        self.assertEqual(diff, '')

450

482

 

451

483

        # Unshelve, should succeed

452

 

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

 

484

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

453

485

 

454

486

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

455

487

 

456

488

        # Make sure relative filenames work ok

457

 

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

 

489

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

458

490

 

459

491

    def test_shelf_shelf_bogus_subcommand(self):

460

492

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

461

 

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

 

493

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

462

494

 

463

495

    def test_shelf_OOO_unshelve(self):

464

496

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

472

504

 

473

505

        # Shelve the changes

474

506

        for i in range(1, 5):

475

 

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

 

507

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

476

508

 

477

509

        # Check shelving worked

478

510

        for i in range(1, 5):

483

515

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

484

516

 

485

517

        # Unshelve 00

486

 

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

 

518

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

487

519

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

488

520

 

489

521

        # Check ls works

490

 

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

 

522

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

491

523

        for line in lines:

492

524

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

493

525

 

494

526

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

495

527

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

496

 

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

 

528

        self.run_bzr('shelve1 --all')

497

529

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

498

530

 

499

531

        # Check ls works

500

 

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

 

532

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

501

533

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

502

534

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

503

535

 

504

536

        # We now have 01,02,03,04

505

537

        # Unshelve 02

506

 

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

 

538

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

507

539

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

508

540

 

509

541

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

510

 

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

 

542

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

511

543

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

512

544

 

513

545

    def test_shelf_switch_basic(self):

516

548

 

517

549

        # This should go to "default"

518

550

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

519

 

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

 

551

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

520

552

 

521

553

        # Switch to "other"

522

 

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

 

554

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

523

555

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

524

 

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

 

556

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

525

557

 

526

558

        # Check it worked

527

559

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

529

561

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

530

562

 

531

563

        # Switch back

532

 

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

 

564

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

533

565

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

534

 

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

 

566

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

535

567

 

536

568

        # Check that worked

537

569

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

538

570

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

539

571

 

 

572

    def test_shelf_binary(self):

 

573

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

 

574

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

 

575

        self.tree.add('file')

 

576

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

 

577

 

540

578

    def test_shelf_bad_patch_arg(self):

541

579

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

542

580

 

543

581

        # Check the bad arg handling

544

 

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

 

582

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

545

583

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

546

584

 

547

 

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

 

585

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

548

586

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

549

587

 

550

588

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

551

 

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

 

589

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

552

590

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

 

591

 

 

592

    def test_color_hunk_selector(self):

 

593

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

 

594

        hs = ShelveHunkSelector([])

 

595

        hs = UnshelveHunkSelector([])

 

596

        try:

 

597

            from bzrlib.plugins.bzrtools import terminal

 

598

        except ImportError:

 

599

            from bzrtools import terminal

 

600

        old_has_ansi_colors = terminal.has_ansi_colors

 

601

        terminal.has_ansi_colors = lambda: False

 

602

        try:

 

603

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

 

604

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

 

605

            terminal.has_ansi_colors = lambda: True

 

606

            hs = ShelveHunkSelector([], color=True)

 

607

            hs = UnshelveHunkSelector([], color=True)

 

608

        finally:

 

609

            terminal.has_ansi_colors = old_has_ansi_colors

 

610

 

 

611

    def test_no_color(self):

 

612

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

 

613

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

 

614

 

 

615

        subdir = 'subdir'

 

616

        os.mkdir(subdir)

 

617

        self.tree.add(subdir)

 

618

        os.chdir(subdir)

 

619

 

 

620

        self.__create_and_add_test_file()

 

621

 

 

622

        # Modify the test file

 

623

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

 

624

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

 

625

        f.write(self.MODIFIED)

 

626

        f.close()

 

627

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

 

628

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

 

629

 

 

630

    def test_shelf_help(self):

 

631

        self.assertContainsRe(cmd_shelf1().help(),

 

632

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

 

633

 

 

634

    def test_show_empty_shelf(self):

 

635

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

 

636

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

• Older »

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