~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/shelf_tests.py

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

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

Show diffs side-by-side

added

removed

tests/shelf_tests.py

1

 

import os.path

 

1

#!/usr/bin/python

 

2

 

2

3

from bzrlib.diff import _patch_header_date

3

4

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 command

11

 

from bzrlib.plugins.bzrtools.command_classes import cmd_shelf1

12

 

 

 

5

import os.path

13

6

 

14

7

class ShelfTests(bzrlib.tests.TestCaseWithTransport):

15

8

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

33

26

+hello test world

34

27

 

35

28

"""

36

 

    def setUp(self):

37

 

        bzrlib.tests.TestCaseWithTransport.setUp(self)

38

 

        command._testing = True

39

 

        self.addCleanup(command._stop_testing)

40

 

 

41

29

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

42

30

        old_tree = self.tree.basis_tree()

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,

 

31

        old_date = _patch_header_date(old_tree, 

 

32

                                      old_tree.inventory.path2id(filename),

 

33

                                      filename)

 

34

        new_date = _patch_header_date(self.tree, 

 

35

                                      self.tree.inventory.path2id(filename),

 

36

                                      filename)

 

37

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

55

38

                 'new_date': new_date}

56

39

        hdr  = self.DIFF_HEADER % keys

57

40

        diff = diff % keys

58

 

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

 

41

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

59

42

 

60

43

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

61

44

                     new_date=None):

62

45

        old_tree = self.tree.basis_tree()

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

 

46

        old_date = _patch_header_date(old_tree, 

 

47

                                      old_tree.inventory.path2id(filename),

 

48

                                      filename)

70

49

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

71

50

                        'new_date': new_date}

72

51

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

83

62

    def __test_loop(self, count):

84

63

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

85

64

        self.__create_and_add_test_file()

86

 

        for counter in range(count):

 

65

 

 

66

        while count > 0:

 

67

            count -= 1

 

68

 

87

69

            # Modify the test file

88

 

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

89

 

            # LF

90

 

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

91

 

            f.write(self.MODIFIED)

92

 

            f.close()

 

70

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

93

71

 

94

72

            self._check_diff()

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

 

73

            

 

74

            new_date = _patch_header_date(self.tree, 

 

75

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

102

76

 

103

77

            # Shelve the changes

104

 

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

 

78

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

105

79

 

106

80

            # Make sure there is no diff anymore

107

 

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

 

81

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

108

82

 

109

83

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

110

84

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

112

86

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

113

87

 

114

88

            # Unshelve

115

 

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

 

89

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

116

90

 

117

91

            self._check_diff()

118

92

 

128

102

        self.__create_and_add_test_file()

129

103

 

130

104

        # Shelve the changes

131

 

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

 

105

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

132

106

 

133

107

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

134

108

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

135

109

            self.fail("Shelf exists, but it shouldn't")

136

110

 

137

111

    def __create_and_add_test_file(self, filename='test_file'):

138

 

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

139

 

        f = open(filename, 'wb')

 

112

        f = open(filename, 'w')

140

113

        f.write(self.ORIGINAL)

141

114

        f.close()

142

115

        self.tree.add(self.tree.relpath(os.path.join(os.getcwd(), filename)))

152

125

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

153

126

 

154

127

        # Shelve the changes

155

 

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

 

128

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

156

129

 

157

130

        self._check_diff(self.DIFF_2)

158

131

 

160

133

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

161

134

 

162

135

        # Unshelve

163

 

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

 

136

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

164

137

 

165

138

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

166

139

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

168

141

    def test_shelf_with_two_revisions(self):

169

142

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

170

143

 

171

 

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

 

144

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

 

145

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

172

146

 

173

147

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

174

148

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

183

157

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

184

158

 

185

159

        # Shelve the changes

186

 

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

 

160

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

187

161

 

188

162

        # Make sure there is no diff anymore

189

 

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

 

163

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

190

164

 

191

165

        # Check the shelf is right

192

166

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

194

168

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

195

169

 

196

170

        # Check the shown output is right

197

 

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

 

171

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

198

172

        self.assertEqual(shown, shelf)

199

173

 

200

174

    def test_shelf_show_multi(self):

210

184

        self.assertTrue('patch 00' in shelf)

211

185

 

212

186

        # Check the shown output is right

213

 

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

 

187

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

214

188

        self.assertEqual(shown, shelf)

215

189

 

216

190

    def test_shelf_show_unspecified(self):

226

200

        self.assertTrue('patch 02' in shelf)

227

201

 

228

202

        # Check the shown output is right

229

 

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

 

203

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

230

204

        self.assertEqual(shown, shelf)

231

205

 

232

206

    def test_shelf_show_with_no_patch(self):

233

207

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

234

 

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

 

208

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

235

209

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

236

210

 

237

211

    def test_shelf_unshelve_failure(self):

243

217

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

244

218

 

245

219

        # Shelve the changes

246

 

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

 

220

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

247

221

 

248

222

        # Write an unapplyable patch into the shelf

249

223

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

252

226

        shelf.close()

253

227

 

254

228

        # Unshelve, should fail

255

 

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

 

229

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

256

230

 

257

231

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

258

232

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

260

234

        self.assertEqual(shelf, self.DIFF_2)

261

235

 

262

236

        # Working tree should be unchanged

263

 

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

 

237

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

264

238

        self.assertEqual(diff, '')

265

239

 

266

240

    def test_shelf_unshelve_failure_two_hunks(self):

274

248

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

275

249

 

276

250

        # Shelve the changes

277

 

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

 

251

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

278

252

 

279

253

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

280

254

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

281

255

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

282

256

 

283

257

        # Unshelve, should fail

284

 

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

 

258

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

285

259

 

286

260

        # Working tree should be unchanged

287

 

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

 

261

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

288

262

        self.assertEqual(diff, '')

289

263

 

290

264

        # Force should succeed and modify test_file2, but leave shelf

291

 

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

 

265

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

292

266

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

293

267

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

294

268

 

303

277

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

304

278

 

305

279

        # Shelve the changes

306

 

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

307

 

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

 

280

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

 

281

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

308

282

 

309

283

        # Unshelve

310

 

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

 

284

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

311

285

 

312

286

        # We should now have 00 and 01~

313

287

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

314

288

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

315

289

 

316

290

        # Check ls works

317

 

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

 

291

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

318

292

        for line in lines:

319

293

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

320

294

 

321

295

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

322

 

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

 

296

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

323

297

 

324

298

    def test_shelf_delete(self):

325

299

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

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

 

300

 

 

301

        self.__create_and_add_test_file()

 

302

        self.__create_and_add_test_file(filename='test_file2')

 

303

 

 

304

        # Modify the test files

 

305

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

 

306

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

 

307

        new_date = _patch_header_date(self.tree, 

 

308

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

343

309

 

344

310

        # Shelve the changes

345

 

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

346

 

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

 

311

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

 

312

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

347

313

 

348

314

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

349

315

 

350

316

        # Delete 00

351

 

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

 

317

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

352

318

 

353

319

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

354

320

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

359

325

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

360

326

 

361

327

        # Check ls works

362

 

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

 

328

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

363

329

        for line in lines:

364

330

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

365

331

 

366

332

        # Unshelve should unshelve 01

367

 

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

 

333

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

368

334

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

369

335

 

370

336

    def test_shelf_gaps(self):

371

337

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

372

338

        self.__create_and_add_test_file()

373

339

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

374

 

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

 

340

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

375

341

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

376

 

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

 

342

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

377

343

 

378

344

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

379

 

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

 

345

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

380

346

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

381

347

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

382

348

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

383

 

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

 

349

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

384

350

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

385

351

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

386

352

 

391

357

 

392

358

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

393

359

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

394

 

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

 

360

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

395

361

 

396

362

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

397

363

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

399

365

 

400

366

        # shelve and unshelve should bitch and do nothing

401

367

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

402

 

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

 

368

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

403

369

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

404

370

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

405

 

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

 

371

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

406

372

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

407

373

 

408

374

        # Upgrade, make sure it worked

409

 

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

 

375

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

410

376

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

411

377

                'First old shelf')

412

378

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

423

389

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

424

390

 

425

391

        # Shelve should work now

426

 

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

 

392

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

427

393

 

428

394

    def test_shelf_p1_patch(self):

429

395

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

431

397

        self.__create_and_add_test_file()

432

398

 

433

399

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

434

 

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

 

400

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

435

401

 

436

402

        old_tree = self.tree.basis_tree()

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

 

403

        old_date = _patch_header_date(old_tree, 

 

404

                                      old_tree.inventory.path2id('test_file'),

 

405

                                      'test_file')

 

406

        new_date = _patch_header_date(self.tree, 

 

407

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

 

408

                                      'test_file')

448

409

        # Fake a -p0 shelved patch

449

410

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

450

411

                               'new_date' : new_date}

453

414

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

454

415

 

455

416

        # This should work

456

 

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

 

417

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

457

418

 

458

419

        self._check_diff()

459

420

 

468

429

        self.__create_and_add_test_file()

469

430

 

470

431

        # Modify the test file

471

 

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

472

 

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

473

 

        f.write(self.MODIFIED)

474

 

        f.close()

 

432

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

475

433

 

476

434

        # Shelve the changes

477

 

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

 

435

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

478

436

 

479

437

        # Working tree should be unchanged

480

 

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

 

438

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

481

439

        self.assertEqual(diff, '')

482

440

 

483

441

        # Unshelve, should succeed

484

 

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

 

442

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

485

443

 

486

444

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

487

445

 

488

446

        # Make sure relative filenames work ok

489

 

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

 

447

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

490

448

 

491

449

    def test_shelf_shelf_bogus_subcommand(self):

492

450

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

493

 

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

 

451

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

494

452

 

495

453

    def test_shelf_OOO_unshelve(self):

496

454

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

504

462

 

505

463

        # Shelve the changes

506

464

        for i in range(1, 5):

507

 

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

 

465

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

508

466

 

509

467

        # Check shelving worked

510

468

        for i in range(1, 5):

515

473

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

516

474

 

517

475

        # Unshelve 00

518

 

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

 

476

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

519

477

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

520

478

 

521

479

        # Check ls works

522

 

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

 

480

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

523

481

        for line in lines:

524

482

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

525

483

 

526

484

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

527

485

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

528

 

        self.run_bzr('shelve1 --all')

 

486

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

529

487

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

530

488

 

531

489

        # Check ls works

532

 

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

 

490

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

533

491

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

534

492

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

535

493

 

536

494

        # We now have 01,02,03,04

537

495

        # Unshelve 02

538

 

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

 

496

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

539

497

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

540

498

 

541

499

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

542

 

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

 

500

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

543

501

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

544

502

 

545

503

    def test_shelf_switch_basic(self):

548

506

 

549

507

        # This should go to "default"

550

508

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

551

 

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

 

509

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

552

510

 

553

511

        # Switch to "other"

554

 

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

 

512

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

555

513

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

556

 

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

 

514

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

557

515

 

558

516

        # Check it worked

559

517

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

561

519

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

562

520

 

563

521

        # Switch back

564

 

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

 

522

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

565

523

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

566

 

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

 

524

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

567

525

 

568

526

        # Check that worked

569

527

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

570

528

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

571

529

 

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

 

 

578

530

    def test_shelf_bad_patch_arg(self):

579

531

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

580

532

 

581

533

        # Check the bad arg handling

582

 

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

 

534

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

583

535

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

584

536

 

585

 

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

 

537

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

586

538

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

587

539

 

588

540

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

589

 

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

 

541

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

590

542

        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