/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/tests/test_blackbox.py

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

• reverse the comparison (7296.10.6 to 7490.22.1)
• stop comparing with revision 7490.22.1

Show diffs side-by-side

added

removed

breezy/git/tests/test_blackbox.py

35

35

from .. import (

36

36

    tests,

37

37

    )

38

 

from ...tests.script import TestCaseWithTransportAndScript

39

38

from ...tests.features import PluginLoadedFeature

40

39

 

41

40

 

49

48

        r1 = builder.commit(b'Joe Foo <joe@foo.com>', u'<The commit message>')

50

49

        return repo, builder.finish()[r1]

51

50

 

52

 

    def test_add(self):

53

 

        r = GitRepo.init(self.test_dir)

54

 

        dir = ControlDir.open(self.test_dir)

55

 

        dir.create_branch()

56

 

        self.build_tree(['a', 'b'])

57

 

        output, error = self.run_bzr(['add', 'a'])

58

 

        self.assertEqual('adding a\n', output)

59

 

        self.assertEqual('', error)

60

 

        output, error = self.run_bzr(

61

 

            ['add', '--file-ids-from=../othertree', 'b'])

62

 

        self.assertEqual('adding b\n', output)

63

 

        self.assertEqual(

64

 

            'Ignoring --file-ids-from, since the tree does not support '

65

 

            'setting file ids.\n', error)

66

 

 

67

51

    def test_nick(self):

68

52

        r = GitRepo.init(self.test_dir)

69

53

        dir = ControlDir.open(self.test_dir)

166

150

        self.assertEqual(b"", output)

167

151

        self.assertTrue(error.endswith(b"Created new branch.\n"))

168

152

 

169

 

    def test_push_without_calculate_revnos(self):

170

 

        self.run_bzr(['init', '--git', 'bla'])

171

 

        self.run_bzr(['init', '--git', 'foo'])

172

 

        self.run_bzr(['commit', '--unchanged', '-m', 'bla', 'foo'])

173

 

        output, error = self.run_bzr(

174

 

            ['push', '-Ocalculate_revnos=no', '-d', 'foo', 'bla'])

175

 

        self.assertEqual("", output)

176

 

        self.assertContainsRe(

177

 

            error,

178

 

            'Pushed up to revision id git(.*).\n')

179

 

 

180

153

    def test_push_lossy_non_mainline(self):

181

154

        self.run_bzr(['init', '--git', 'bla'])

182

155

        self.run_bzr(['init', 'foo'])

191

164

        self.assertEqual(

192

165

            'Pushing from a Bazaar to a Git repository. For better '

193

166

            'performance, push into a Bazaar repository.\n'

194

 

            'All changes applied successfully.\n'

195

 

            'Pushed up to revision 2.\n', error)

196

 

 

197

 

    def test_push_lossy_non_mainline_incremental(self):

198

 

        self.run_bzr(['init', '--git', 'bla'])

199

 

        self.run_bzr(['init', 'foo'])

200

 

        self.run_bzr(['commit', '--unchanged', '-m', 'bla', 'foo'])

201

 

        self.run_bzr(['commit', '--unchanged', '-m', 'bla', 'foo'])

202

 

        output, error = self.run_bzr(['push', '--lossy', '-d', 'foo', 'bla'])

203

 

        self.assertEqual("", output)

204

 

        self.assertEqual(

205

 

            'Pushing from a Bazaar to a Git repository. For better '

206

 

            'performance, push into a Bazaar repository.\n'

207

 

            'All changes applied successfully.\n'

208

 

            'Pushed up to revision 2.\n', error)

209

 

        self.run_bzr(['commit', '--unchanged', '-m', 'bla', 'foo'])

210

 

        output, error = self.run_bzr(['push', '--lossy', '-d', 'foo', 'bla'])

211

 

        self.assertEqual("", output)

212

 

        self.assertEqual(

213

 

            'Pushing from a Bazaar to a Git repository. For better '

214

 

            'performance, push into a Bazaar repository.\n'

215

 

            'All changes applied successfully.\n'

216

 

            'Pushed up to revision 3.\n', error)

 

167

            'Pushed up to revision 2.\n', error)

217

168

 

218

169

    def test_log(self):

219

170

        # Smoke test for "bzr log" in a git repository.

232

183

 

233

184

        # Check that bzr log does not fail and includes the revision.

234

185

        output, error = self.run_bzr(['log', '-v'])

235

 

        self.assertContainsRe(output, 'revno: 1')

236

 

 

237

 

    def test_log_without_revno(self):

238

 

        # Smoke test for "bzr log -v" in a git repository.

239

 

        self.simple_commit()

240

 

 

241

 

        # Check that bzr log does not fail and includes the revision.

242

 

        output, error = self.run_bzr(['log', '-Ocalculate_revnos=no'])

243

 

        self.assertNotContainsRe(output, 'revno: 1')

244

 

 

245

 

    def test_commit_without_revno(self):

246

 

        repo = GitRepo.init(self.test_dir)

247

 

        output, error = self.run_bzr(

248

 

            ['commit', '-Ocalculate_revnos=yes', '--unchanged', '-m', 'one'])

249

 

        self.assertContainsRe(error, 'Committed revision 1.')

250

 

        output, error = self.run_bzr(

251

 

            ['commit', '-Ocalculate_revnos=no', '--unchanged', '-m', 'two'])

252

 

        self.assertNotContainsRe(error, 'Committed revision 2.')

253

 

        self.assertContainsRe(error, 'Committed revid .*.')

254

 

 

255

 

    def test_log_file(self):

256

 

        # Smoke test for "bzr log" in a git repository.

257

 

        repo = GitRepo.init(self.test_dir)

258

 

        builder = tests.GitBranchBuilder()

259

 

        builder.set_file('a', b'text for a\n', False)

260

 

        r1 = builder.commit(b'Joe Foo <joe@foo.com>', u'First')

261

 

        builder.set_file('a', b'text 3a for a\n', False)

262

 

        r2a = builder.commit(b'Joe Foo <joe@foo.com>', u'Second a', base=r1)

263

 

        builder.set_file('a', b'text 3b for a\n', False)

264

 

        r2b = builder.commit(b'Joe Foo <joe@foo.com>', u'Second b', base=r1)

265

 

        builder.set_file('a', b'text 4 for a\n', False)

266

 

        builder.commit(b'Joe Foo <joe@foo.com>', u'Third', merge=[r2a], base=r2b)

267

 

        builder.finish()

268

 

 

269

 

        # Check that bzr log does not fail and includes the revision.

270

 

        output, error = self.run_bzr(['log', '-n2', 'a'])

271

 

        self.assertEqual(error, '')

272

 

        self.assertIn('Second a', output)

273

 

        self.assertIn('Second b', output)

274

 

        self.assertIn('First', output)

275

 

        self.assertIn('Third', output)

276

186

 

277

187

    def test_tags(self):

278

188

        git_repo, commit_sha1 = self.simple_commit()

302

212

        tree.add(['a'])

303

213

        output, error = self.run_bzr(['diff', '--format=git'], retcode=1)

304

214

        self.assertEqual(error, '')

305

 

        # Some older versions of Dulwich (< 0.19.12) formatted diffs slightly

306

 

        # differently.

307

 

        from dulwich import __version__ as dulwich_version

308

 

        if dulwich_version < (0, 19, 12):

309

 

            self.assertEqual(output,

310

 

                             'diff --git /dev/null b/a\n'

311

 

                             'old mode 0\n'

312

 

                             'new mode 100644\n'

313

 

                             'index 0000000..c197bd8 100644\n'

314

 

                             '--- /dev/null\n'

315

 

                             '+++ b/a\n'

316

 

                             '@@ -0,0 +1 @@\n'

317

 

                             '+contents of a\n')

318

 

        else:

319

 

            self.assertEqual(output,

320

 

                             'diff --git a/a b/a\n'

321

 

                             'old file mode 0\n'

322

 

                             'new file mode 100644\n'

323

 

                             'index 0000000..c197bd8 100644\n'

324

 

                             '--- /dev/null\n'

325

 

                             '+++ b/a\n'

326

 

                             '@@ -0,0 +1 @@\n'

327

 

                             '+contents of a\n')

 

215

        self.assertEqual(output,

 

216

                         'diff --git a/a b/a\n'

 

217

                         'old file mode 0\n'

 

218

                         'new file mode 100644\n'

 

219

                         'index 0000000..c197bd8 100644\n'

 

220

                         '--- /dev/null\n'

 

221

                         '+++ b/a\n'

 

222

                         '@@ -0,0 +1 @@\n'

 

223

                         '+contents of a\n')

328

224

 

329

225

    def test_git_import_uncolocated(self):

330

226

        r = GitRepo.init("a", mkdir=True)

349

245

        self.run_bzr(["git-import", "--colocated", "a", "b"])

350

246

        self.assertEqual(set([".bzr"]), set(os.listdir("b")))

351

247

        self.assertEqual(set(["abranch", "bbranch"]),

352

 

                         set(ControlDir.open("b").branch_names()))

 

248

                         set(ControlDir.open("b").get_branches().keys()))

353

249

 

354

250

    def test_git_import_incremental(self):

355

251

        r = GitRepo.init("a", mkdir=True)

361

257

        self.run_bzr(["git-import", "--colocated", "a", "b"])

362

258

        self.assertEqual(set([".bzr"]), set(os.listdir("b")))

363

259

        b = ControlDir.open("b")

364

 

        self.assertEqual(["abranch"], b.branch_names())

 

260

        self.assertEqual(["abranch"], list(b.get_branches().keys()))

365

261

 

366

262

    def test_git_import_tags(self):

367

263

        r = GitRepo.init("a", mkdir=True)

373

269

        self.run_bzr(["git-import", "--colocated", "a", "b"])

374

270

        self.assertEqual(set([".bzr"]), set(os.listdir("b")))

375

271

        b = ControlDir.open("b")

376

 

        self.assertEqual(["abranch"], b.branch_names())

 

272

        self.assertEqual(["abranch"], list(b.get_branches().keys()))

377

273

        self.assertEqual(["atag"],

378

274

                         list(b.open_branch("abranch").tags.get_tag_dict().keys()))

379

275

 

426

322

        self.assertEqual(out, '')

427

323

        self.assertTrue(err.endswith, '3 objects\n')

428

324

 

429

 

    def test_local_whoami(self):

430

 

        r = GitRepo.init("gitr", mkdir=True)

431

 

        self.build_tree_contents([('gitr/.git/config', """\

432

 

[user]

433

 

  email = some@example.com

434

 

  name = Test User

435

 

""")])

436

 

        out, err = self.run_bzr(["whoami", "-d", "gitr"])

437

 

        self.assertEqual(out, "Test User <some@example.com>\n")

438

 

        self.assertEqual(err, "")

439

 

 

440

 

        self.build_tree_contents([('gitr/.git/config', """\

441

 

[user]

442

 

  email = some@example.com

443

 

""")])

444

 

        out, err = self.run_bzr(["whoami", "-d", "gitr"])

445

 

        self.assertEqual(out, "some@example.com\n")

446

 

        self.assertEqual(err, "")

447

 

 

448

 

    def test_local_signing_key(self):

449

 

        r = GitRepo.init("gitr", mkdir=True)

450

 

        self.build_tree_contents([('gitr/.git/config', """\

451

 

[user]

452

 

  email = some@example.com

453

 

  name = Test User

454

 

  signingkey = D729A457

455

 

""")])

456

 

        out, err = self.run_bzr(["config", "-d", "gitr", "gpg_signing_key"])

457

 

        self.assertEqual(out, "D729A457\n")

458

 

        self.assertEqual(err, "")

459

 

 

460

325

 

461

326

class ShallowTests(ExternalBase):

462

327

 

543

408

            with basis_tree.lock_read():

544

409

                self.assertEqual([], list(tree.iter_changes(basis_tree)))

545

410

 

546

 

    def test_branch_with_nested_trees(self):

547

 

        orig = self.make_branch_and_tree('source', format='git')

548

 

        subtree = self.make_branch_and_tree('source/subtree', format='git')

549

 

        self.build_tree(['source/subtree/a'])

550

 

        self.build_tree_contents([('source/.gitmodules', """\

551

 

[submodule "subtree"]

552

 

    path = subtree

553

 

    url = %s

554

 

""" % subtree.user_url)])

555

 

        subtree.add(['a'])

556

 

        subtree.commit('add subtree contents')

557

 

        orig.add_reference(subtree)

558

 

        orig.add(['.gitmodules'])

559

 

        orig.commit('add subtree')

560

 

 

561

 

        self.run_bzr('branch source target')

562

 

 

563

 

        target = WorkingTree.open('target')

564

 

        target_subtree = WorkingTree.open('target/subtree')

565

 

        self.assertTreesEqual(orig, target)

566

 

        self.assertTreesEqual(subtree, target_subtree)

567

 

 

568

 

 

569

 

class SwitchScriptTests(TestCaseWithTransportAndScript):

570

 

 

571

 

    def test_switch_preserves(self):

572

 

        # See https://bugs.launchpad.net/brz/+bug/1820606

573

 

        self.run_script("""

574

 

$ brz init --git r

575

 

Created a standalone tree (format: git)

576

 

$ cd r

577

 

$ echo original > file.txt

578

 

$ brz add

579

 

adding file.txt

580

 

$ brz ci -q -m "Initial"

581

 

$ echo "entered on master branch" > file.txt

582

 

$ brz stat

583

 

modified:

584

 

  file.txt

585

 

$ brz switch -b other

586

 

2>Tree is up to date at revision 1.

587

 

2>Switched to branch other

588

 

$ cat file.txt

589

 

entered on master branch

590

 

""")

591

 

 

592

411

 

593

412

class GrepTests(ExternalBase):

594

413

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0