~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/test_baz_import.py

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

• reverse the comparison (528 to 147.4.30)
• stop comparing with revision 147.4.30

Show diffs side-by-side

added

removed

tests/test_baz_import.py

16

16

#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

17

17

 

18

18

from bzrlib.tests import TestCaseInTempDir, TestCase

 

19

from bzrlib import repository

19

20

from bzrlib.osutils import has_symlinks

20

21

try:

21

22

    import pybaz

22

23

except ImportError:

23

24

    pybaz = None

24

25

import os

25

 

from bzrlib.plugins.bzrtools.baz_import import (import_version, revision_id, 

26

 

                                                cmd_baz_import, make_archive)

27

 

from bzrlib.errors import NoSuchRevision

 

26

from bzrlib.plugins.bzrtools import cmd_baz_import 

 

27

from bzrlib.plugins.bzrtools.baz_import import (import_version, 

 

28

                                                revision_id,

 

29

                                                make_archive,

 

30

                                                map_file_id)

28

31

import shutil

29

32

from StringIO import StringIO

30

33

import tempfile

31

34

from testresources import (TestResource, TestLoader, OptimisingTestSuite,

32

35

                               ResourcedTestCase)

33

36

    

 

37

import bzrlib

 

38

from bzrlib.errors import NoSuchRevision

34

39

from bzrlib.plugins.bzrtools.fai import namespace_previous

35

40

from bzrlib.branch import Branch

36

41

 

59

64

        pybaz.set_my_id("Test User<test@example.org>")

60

65

 

61

66

        self.make_empty_import()

 

67

        self.make_utf8_log()

62

68

 

63

69

        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'

64

 

        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')

 

70

        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0', None)

65

71

        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(

66

72

            pybaz.Version(self._empty_tag))

67

73

 

68

74

        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'

69

75

        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 

70

 

                                                 + '--base-0')

 

76

                                                 + '--base-0', None)

71

77

        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 

72

 

                                                 + '--patch-1')

 

78

                                                 + '--patch-1', None)

73

79

        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(

74

80

            pybaz.Version(self._empty_merged_tag))

75

81

        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(

84

90

        # tree, two commits, includes merge of other branch

85

91

        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'

86

92

        self._empty_merged_tag_2_bzr_base = revision_id(

87

 

            self._empty_merged_tag_2 + '--base-0')

 

93

            self._empty_merged_tag_2 + '--base-0', None)

88

94

        self._empty_merged_tag_2_bzr = revision_id(

89

 

            self._empty_merged_tag_2 + '--patch-1')

 

95

            self._empty_merged_tag_2 + '--patch-1', None)

90

96

        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(

91

97

            pybaz.Version(self._empty_merged_tag_2))

92

98

        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (

99

105

        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))

100

106

 

101

107

        self._bad_id_tag = 'demo@DONOTUSE/c--bad-id--0'

102

 

        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0')

103

 

        self._bad_id_tag_bzr = revision_id(self._bad_id_tag + '--patch-1')

 

108

        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0',

 

109

                                                None)

 

110

        self._bad_id_tag_bzr = revision_id(self._bad_id_tag + '--patch-1',

 

111

                                           None)

104

112

        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(

105

113

            pybaz.Version(self._bad_id_tag))

106

114

        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(

120

128

    def make_import_symlink(self):

121

129

        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'

122

130

        self._import_symlink_bzr = revision_id(

123

 

            self._import_symlink + '--base-0')

 

131

            self._import_symlink + '--base-0', None)

124

132

        os.mkdir(os.path.join(self._tmpdir, 'tree'))

125

133

        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),

126

134

                               self._import_symlink)

127

 

        os.symlink('missing-file-name',

128

 

                   os.path.join(self._tmpdir, 'tree', 'alink'))

 

135

        link_path = os.path.join(self._tmpdir, 'tree', 'alink')

 

136

        os.symlink('missing-file-name', link_path)

129

137

        tree.add_tag('alink')

130

138

        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')

131

139

        id_file.write('symlink_tag\n')

133

141

        msg = tree.log_message()

134

142

        msg["summary"] = "Import with a symlink"

135

143

        tree.import_(msg)

 

144

        os.unlink(link_path)

 

145

        f = file(link_path, 'w')

 

146

        f.write('Not a symlink no more!')

 

147

        f.close()

 

148

        msg = tree.log_message()

 

149

        msg["summary"] = "Turn a symlink into a file"

 

150

        tree.commit(msg)

136

151

        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))

137

152

 

138

153

    def make_empty_import(self):

145

160

        tree.import_(msg)

146

161

        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))

147

162

 

 

163

    def make_utf8_log(self):

 

164

        self._utf8 = 'demo@DONOTUSE/c--utf8--0'

 

165

        os.mkdir(os.path.join(self._tmpdir, 'tree'))

 

166

        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 

 

167

                               self._utf8)

 

168

        msg = tree.log_message()

 

169

        msg["summary"] = u"I am importing now\u1234".encode('utf-8')

 

170

        tree.import_(msg)

 

171

        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))

 

172

 

148

173

    def make_missing_ancestor(self):

149

174

        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')

150

175

        self._archive = make_archive('demo-gone@DONOTUSE',

151

176

                                     str(self._archivegoneroot))

152

177

        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'

153

178

        self._missing_import_bzr = revision_id(self._missing_import 

154

 

                                                 + '--base-0')

 

179

                                                 + '--base-0', None)

155

180

        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'

156

181

        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 

157

 

                                                 + '--base-0')

 

182

                                                 + '--base-0', None)

158

183

        os.mkdir(os.path.join(self._tmpdir, 'tree'))

159

184

        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 

160

185

                               self._missing_import)

167

192

            pybaz.Version(self._missing_ancestor))

168

193

 

169

194

        # make an import for testing history-reuse logic.

170

 

        def collect(text):

171

 

            pass

172

195

        # note the use of a namespace layout here.

173

196

        self._missing_import_imported = os.path.join(self._tmpdir, 

174

197

                                                     'archivegone-bzr')

176

199

        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))

177

200

        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 

178

201

                                    'c', 'import'),

179

 

                       pybaz.Version(self._missing_import),

180

 

                       collect)

 

202

                       pybaz.Version(self._missing_import), None)

181

203

        # and make it inaccessible

182

204

        pybaz.Archive('demo-gone@DONOTUSE').unregister()

183

205

 

184

206

    def make_inbranch_continuation(self):

185

207

        self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'

186

208

        self._inbranch_tag_base = self._inbranch_tag + '--base-0'

187

 

        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base)

 

209

        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base, 

 

210

                                                  None)

188

211

        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(

189

212

            pybaz.Version(self._inbranch_tag))

190

213

        self._inbranch_tag_head = self._inbranch_tag + '--patch-1'

191

 

        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head)

 

214

        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head,

 

215

                                                  None)

192

216

        pybaz.Revision(self._inbranch_tag_base).make_continuation(

193

217

            pybaz.Version(self._inbranch_tag))

194

218

 

209

233

        TestCaseInTempDir.setUp(self)

210

234

        ResourcedTestCase.setUpResources(self)

211

235

        os.environ['HOME'] = self._baz._homedir

212

 

        self.output = StringIO()

213

236

 

214

237

    def tearDown(self):

215

238

        ResourcedTestCase.tearDownResources(self)

216

239

        TestCaseInTempDir.tearDown(self)

217

 

 

218

 

    def collect(self, text):

219

 

        self.output.write(text)

220

 

        self.output.write("\n")

221

 

 

 

240

 

 

241

    def test_import_utf8(self):

 

242

        import_version('output', pybaz.Version(self._baz._utf8), None)

 

243

        branch = Branch.open('output')

 

244

        plain_revid = 'Arch-1:demo@DONOTUSE%c--utf8--0--base-0'

 

245

        self.assertEqual([plain_revid], branch.revision_history())

 

246

        self.assertEqual(u'I am importing now\ufffd\ufffd\ufffd',

 

247

                         branch.repository.get_revision(plain_revid).message)

 

248

        import_version('output2', pybaz.Version(self._baz._utf8), 'utf-8')

 

249

        branch2 = Branch.open('output2')

 

250

        utf8_revid = 'Arch-1-utf-8:demo@DONOTUSE%c--utf8--0--base-0'

 

251

        self.assertEqual([utf8_revid], branch2.revision_history())

 

252

        self.assertEqual(u'I am importing now\u1234',

 

253

                         branch2.repository.get_revision(utf8_revid).message)

 

254

 

222

255

    def test_import_empty(self):

223

 

        import_version('output', pybaz.Version(self._baz._import), 

224

 

                       self.collect)

 

256

        import_version('output', pybaz.Version(self._baz._import), None)

225

257

        # expected results:

226

258

        # one commit, no files, revision identifier of 

227

259

        # 'demo@DONOTUSE_c--import--0--base-0'

232

264

        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')

233

265

        # and again.

234

266

        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),

235

 

                       self.collect)

 

267

                       None)

236

268

        branch2 = Branch.open('output2')

237

269

        repo2 = branch2.repository

238

270

        self.assertEqual(branch.revision_history(), branch2.revision_history())

247

279

                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")

248

280

 

249

281

    def test_empty_tagged(self):

250

 

        import_version('output', pybaz.Version(self._baz._empty_tag),

251

 

                       self.collect)

 

282

        import_version('output', pybaz.Version(self._baz._empty_tag), None)

252

283

        # expected results:

253

284

        # two commits, no files, revision identifiers of 

254

285

        # 'demo@DONOTUSE_c--import--0--base-0' and

259

290

                          self._baz._empty_tag_bzr])

260

291

        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)

261

292

        # and again.

262

 

        import_version('output2', pybaz.Version(self._baz._empty_tag),

263

 

                       self.collect)

 

293

        import_version('output2', pybaz.Version(self._baz._empty_tag), None)

264

294

        branch2 = Branch.open('output2')

265

295

        self.assertEqual(branch.revision_history(), branch2.revision_history())

266

296

        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)

274

304

        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)

275

305

 

276

306

    def test_empty_merged_tagged(self):

277

 

        import_version('output', pybaz.Version(self._baz._empty_merged_tag),

278

 

                       self.collect)

 

307

        import_version('output', pybaz.Version(self._baz._empty_merged_tag), 

 

308

                       None)

279

309

        # expected results:

280

310

        # two commits, no files, revision identifiers of 

281

311

        # 'demo@DONOTUSE_c--import--0--base-0' and

290

320

                          self._baz._empty_merged_tag_bzr_base,

291

321

                          self._baz._empty_merged_tag_bzr])

292

322

        # and again.

293

 

        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),

294

 

                       self.collect)

 

323

        import_version('output2', pybaz.Version(self._baz._empty_merged_tag), 

 

324

                       None)

295

325

        branch2 = Branch.open('output2')

296

326

        repo2 = branch2.repository

297

327

        # and import what we should be merged up against for checking with.

298

 

        import_version('output3', pybaz.Version(self._baz._empty_tag),

299

 

                       self.collect)

 

328

        import_version('output3', pybaz.Version(self._baz._empty_tag), None)

300

329

        branch3 = Branch.open('output3')

301

330

        

302

331

        self.assertEqual(branch.revision_history(), branch2.revision_history())

333

362

        # self.assertEqual(branch.missing_revisions(branch3), [])

334

363

        

335

364

    def test_merge_branch_with_merges(self):

336

 

        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),

337

 

                       self.collect)

 

365

        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2), 

 

366

                       None)

338

367

        # expected results:

339

368

        # two commits, no files, revision identifiers of 

340

369

        # 'demo@DONOTUSE_c--import--0--base-0' and

350

379

                          self._baz._empty_merged_tag_2_bzr])

351

380

        # and again.

352

381

        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),

353

 

                       self.collect)

 

382

                       None)

354

383

        branch2 = Branch.open('output2')

355

384

        repo2 = branch2.repository

356

385

        # and import what we should be merged up against for checking with.

357

386

        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),

358

 

                       self.collect)

 

387

                       None)

359

388

        branch3 = Branch.open('output3')

360

389

        

361

390

        self.assertEqual(branch.revision_history(), branch2.revision_history())

392

421

        # self.assertEqual(branch.missing_revisions(branch3), [])

393

422

        

394

423

    def test_import_symlink(self):

395

 

        import_version('output', pybaz.Version(self._baz._import_symlink),

396

 

                       self.collect)

 

424

        import_version('output', pybaz.Version(self._baz._import_symlink), 

 

425

                       None, max_count=1)

397

426

        # expected results:

398

 

        # one commit, no files, revision identifier of 

 

427

        # two commits, no files, revision identifier of 

399

428

        # 'demo@DONOTUSE_c--import--0--base-0'

400

429

        branch = Branch.open('output')

401

430

        self.assertEqual(branch.revision_history(),

403

432

        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)

404

433

        # and again.

405

434

        import_version('output2', pybaz.Version(self._baz._import_symlink),

406

 

                       self.collect)

 

435

                       None, max_count=1)

407

436

        branch2 = Branch.open('output2')

408

437

        self.assertEqual(branch.revision_history(), branch2.revision_history())

409

438

        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)

422

451

        self.assertEqual(entry.kind, 'symlink')

423

452

        self.assertEqual(entry.symlink_target, 'missing-file-name')

424

453

 

 

454

        # Test kind change for import

 

455

        import_version('output3', pybaz.Version(self._baz._import_symlink),

 

456

                       None)

 

457

 

425

458

    def test_missing_ancestor(self):

426

459

        import_version('output', pybaz.Version(self._baz._missing_ancestor),

427

 

                       self.collect)

 

460

                       None)

428

461

        # expected results:

429

462

        # one commits, no files, revision identifiers of 

430

463

        # 'demo@DONOTUSE_c--gone--0--base-0' and

434

467

                         [self._baz._missing_ancestor_bzr])

435

468

        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)

436

469

        # and again.

437

 

        import_version('output2', pybaz.Version(self._baz._missing_ancestor),

438

 

                       self.collect)

 

470

        import_version('output2', pybaz.Version(self._baz._missing_ancestor), 

 

471

                       None)

439

472

        branch2 = Branch.open('output2')

440

473

        self.assertEqual(branch.revision_history(), branch2.revision_history())

441

474

        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)

456

489

 

457

490

    def test_missing_ancestor_reusing_history(self):

458

491

        import_version('output', pybaz.Version(self._baz._missing_ancestor),

459

 

                       self.collect,

 

492

                       None,

460

493

                       reuse_history_from=[self._baz._missing_import_imported])

461

494

        # expected results:

462

495

        # one commits, no files, revision identifiers of 

469

502

        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)

470

503

        # and again.

471

504

        import_version('output2', pybaz.Version(self._baz._missing_ancestor),

472

 

                       self.collect,

 

505

                       None,

473

506

                       reuse_history_from=[self._baz._missing_import_imported])

474

507

        branch2 = Branch.open('output2')

475

508

        self.assertEqual(branch.revision_history(), branch2.revision_history())

489

522

        self.assertEqual(1, len(rev.parent_ids))

490

523

 

491

524

    def test_bad_file_id(self):

492

 

        import_version('output', pybaz.Version(self._baz._bad_id_tag),

493

 

                       self.collect)

 

525

        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)

494

526

        # expected results:

495

527

        # three commits, one files, revision identifiers of 

496

528

        # 'demo@DONOTUSE_c--import--0--base-0' ,

507

539

        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))

508

540

 

509

541

    def test_appending_revisions_already_present(self):

510

 

        import_version('output', pybaz.Version(self._baz._bad_id_tag),

511

 

                       self.collect, max_count=2)

 

542

        import_version('output', pybaz.Version(self._baz._bad_id_tag), None,

 

543

                       max_count=2)

512

544

        # expected results:

513

545

        # three commits, one files, revision identifiers of 

514

546

        # 'demo@DONOTUSE_c--import--0--base-0' ,

525

557

        self.assertEqual(branch.revision_history(),

526

558

                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])

527

559

        del branch

528

 

        import_version('output', pybaz.Version(self._baz._bad_id_tag),

529

 

                       self.collect)

 

560

        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)

530

561

        branch = Branch.open('output')

531

562

        self.assertEqual(branch.revision_history(),

532

563

                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',

538

569

        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))

539

570

 

540

571

    def test_appending_revisions_all_already_present(self):

541

 

        import_version('output', pybaz.Version(self._baz._bad_id_tag),

542

 

                       self.collect)

 

572

        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)

543

573

        # expected results:

544

574

        # three commits, one files, revision identifiers of 

545

575

        # 'demo@DONOTUSE_c--import--0--base-0' ,

557

587

        self.assertEqual(branch.revision_history(),

558

588

                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])

559

589

        del branch

560

 

        import_version('output', pybaz.Version(self._baz._bad_id_tag),

561

 

                       self.collect)

 

590

        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)

562

591

        branch = Branch.open('output')

563

592

        self.assertEqual(branch.revision_history(),

564

593

                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',

570

599

        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))

571

600

 

572

601

    def test_inbranch_conversion(self):

573

 

        import_version('output', pybaz.Version(self._baz._inbranch_tag),

574

 

                       self.collect)

 

602

        import_version('output', pybaz.Version(self._baz._inbranch_tag), None)

575

603

        # expected results:

576

604

        # three commits, no files, revision identifiers of 

577

605

        # 'demo@DONOTUSE_c--import--0--base-0' and

584

612

                          self._baz._inbranch_tag_base_bzr,

585

613

                          self._baz._inbranch_tag_head_bzr])

586

614

        # and again.

587

 

        import_version('output2', pybaz.Version(self._baz._inbranch_tag),

588

 

                       self.collect)

 

615

        import_version('output2', pybaz.Version(self._baz._inbranch_tag), None)

589

616

        branch2 = Branch.open('output2')

590

617

        

591

618

        self.assertEqual(branch.revision_history(), branch2.revision_history())

611

638

        self.assertEqual(rev.parent_ids,

612

639

                         [self._baz._inbranch_tag_base_bzr])

613

640

 

 

641

    def test_no_commits_same_as_missing(self):

 

642

        path = 'output'

 

643

        os.mkdir(path)

 

644

        branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(path)

 

645

        import_version(path, pybaz.Version(self._baz._import), None)

 

646

        # expected results:

 

647

        # one commit, revision identifier of 

 

648

        # 'demo@DONOTUSE_c--import--0--base-0'

 

649

        self.assertEqual(branch.revision_history(),

 

650

                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])

 

651

 

614

652

 

615

653

class TestNamespacePrevious(TestCase):

616

654

 

641

679

        self.assertEqual(namespace_previous(self.version['versionfix-3000']),

642

680

                         self.version['versionfix-2999'])

643

681

 

 

682

 

644

683

class TestNamespaceMapping(TestCase):

645

684

 

646

685

    def test_namespace_mapping_branch(self):

663

702

class TestFileIdMapping(TestCase):

664

703

 

665

704

    def test_slash(self):

666

 

        from bzrlib.plugins.bzrtools.baz_import import map_file_id

667

705

        self.assertEqual('c%2fc', map_file_id('c/c'))

668

706

        self.assertEqual('c%25c', map_file_id('c%c'))

669

707

 

696

734

        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))

697

735

 

698

736

    def test_cmd_exists(self):

699

 

        from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import

 

737

        from bzrlib.plugins.bzrtools import cmd_baz_import

700

738

 

701

739

    def test_empty_archive(self):

702

740

        command = cmd_baz_import()

703

741

        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')

704

742

        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))

705

743

        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))

706

 

        self.assertEqual(6, walk_len)

 

744

        self.assertEqual(7, walk_len)

707

745

 

708

746

    def test_two_branches(self):

709

747

        self.make_import('c--0')

715

753

                                       'c','+trunk')))

716

754

        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 

717

755

                                                    'c1', '0.2','branch')))

 

756

        default_format = repository.RepositoryFormat.get_default_format()

 

757

        if getattr(default_format, 'rich_root_data', False):

 

758

            num_files = 21

 

759

        else:

 

760

            num_files = 20

718

761

        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))

719

 

        self.assertEqual(17, walk_len)

 

762

        self.assertEqual(num_files, walk_len)

720

763

 

721

764

    def test_run_twice(self):

722

765

        self.make_import('c--0')

733

776

        self.make_import('c--0')

734

777

        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),

735

778

                     'demo@DONOTUSE')

 

779

 

 

780

    def test_does_not_need_reuse_history(self):

 

781

        self.make_import('c--0')

 

782

        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),

 

783

                     'demo@DONOTUSE')

 

784

 

 

785

    def test_encoding_flag(self):

 

786

        self.make_import('c--0')

 

787

        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),

 

788

                     'demo@DONOTUSE')

 

789

        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'], 

 

790

                         Branch.open(os.path.join(self._tmpdir, 

 

791

                                     'output/c/+trunk')).revision_history())

 

792

        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output2'),

 

793

                     'demo@DONOTUSE', '--encoding', 'utf-8')

 

794

        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'], 

 

795

                         Branch.open(os.path.join(self._tmpdir, 

 

796

                                     'output2/c/+trunk')).revision_history())

 

797

        self.run_bzr('baz-import-branch', os.path.join(self._tmpdir, 'output3'),

 

798

                     'demo@DONOTUSE/c--0')

 

799

        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'], 

 

800

                         Branch.open(os.path.join(self._tmpdir, 

 

801

                                     'output3')).revision_history())

 

802

        self.run_bzr('baz-import-branch', os.path.join(self._tmpdir, 

 

803

                      'output4'), 'demo@DONOTUSE/c--0', '--encoding', 'utf-8')

 

804

        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'], 

 

805

                         Branch.open(os.path.join(self._tmpdir, 

 

806

                                     'output4')).revision_history())

• Older »

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