~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

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

• reverse the comparison (3287 to 6217)
• stop comparing with revision 6217

Show diffs side-by-side

added

removed

bzrlib/tests/test_revision.py

1

 

# Copyright (C) 2005-2011 Canonical Ltd

 

1

# Copyright (C) 2005 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

12

12

#

13

13

# You should have received a copy of the GNU General Public License

14

14

# along with this program; if not, write to the Free Software

15

 

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

16

 

 

17

 

 

 

15

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

 

16

 

 

17

 

 

18

import os

18

19

import warnings

19

20

 

20

21

from bzrlib import (

21

 

    bugtracker,

22

22

    revision,

23

 

    )

24

 

from bzrlib.errors import (

25

 

    InvalidBugStatus,

26

 

    InvalidLineInBugsProperty,

27

 

    )

28

 

from bzrlib.revision import NULL_REVISION

 

23

    symbol_versioning,

 

24

    )

 

25

from bzrlib.branch import Branch

 

26

from bzrlib.errors import NoSuchRevision

 

27

from bzrlib.deprecated_graph import Graph

 

28

from bzrlib.revision import (find_present_ancestors, combined_graph,

 

29

                             common_ancestor,

 

30

                             is_ancestor, MultipleRevisionSources,

 

31

                             NULL_REVISION)

 

32

from bzrlib.symbol_versioning import one_zero, one_three

29

33

from bzrlib.tests import TestCase, TestCaseWithTransport

30

 

from bzrlib.tests.matchers import MatchesAncestry

 

34

from bzrlib.trace import mutter

 

35

from bzrlib.workingtree import WorkingTree

31

36

 

32

37

# We're allowed to test deprecated interfaces

33

38

warnings.filterwarnings('ignore',

44

49

 

45

50

    the object graph is

46

51

    B:     A:

47

 

    a..0   a..0

 

52

    a..0   a..0 

48

53

    a..1   a..1

49

54

    a..2   a..2

50

55

    b..3   a..3 merges b..4

57

62

    """

58

63

    tree1 = self.make_branch_and_tree("branch1", format=format)

59

64

    br1 = tree1.branch

60

 

 

 

65

    

61

66

    tree1.commit("Commit one", rev_id="a@u-0-0")

62

67

    tree1.commit("Commit two", rev_id="a@u-0-1")

63

68

    tree1.commit("Commit three", rev_id="a@u-0-2")

64

69

 

65

 

    tree2 = tree1.bzrdir.sprout("branch2").open_workingtree()

 

70

    tree2 = tree1.bzrdir.clone("branch2").open_workingtree()

66

71

    br2 = tree2.branch

67

72

    tree2.commit("Commit four", rev_id="b@u-0-3")

68

73

    tree2.commit("Commit five", rev_id="b@u-0-4")

69

 

    self.assertEquals(br2.last_revision(), 'b@u-0-4')

70

 

 

 

74

    revisions_2 = br2.revision_history()

 

75

    self.assertEquals(revisions_2[-1], 'b@u-0-4')

 

76

    

71

77

    tree1.merge_from_branch(br2)

72

78

    tree1.commit("Commit six", rev_id="a@u-0-3")

73

79

    tree1.commit("Commit seven", rev_id="a@u-0-4")

74

80

    tree2.commit("Commit eight", rev_id="b@u-0-5")

75

 

    self.assertEquals(br2.last_revision(), 'b@u-0-5')

76

 

 

 

81

    self.assertEquals(br2.revision_history()[-1], 'b@u-0-5')

 

82

    

77

83

    tree1.merge_from_branch(br2)

78

84

    tree1.commit("Commit nine", rev_id="a@u-0-5")

79

85

    # DO NOT MERGE HERE - we WANT a GHOST.

80

 

    br1.lock_read()

81

 

    try:

82

 

        graph = br1.repository.get_graph()

83

 

        revhistory = list(graph.iter_lefthand_ancestry(br1.last_revision(),

84

 

            [revision.NULL_REVISION]))

85

 

        revhistory.reverse()

86

 

    finally:

87

 

        br1.unlock()

88

 

    tree2.add_parent_tree_id(revhistory[4])

 

86

    tree2.add_parent_tree_id(br1.revision_history()[4])

89

87

    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")

90

 

 

 

88

    

91

89

    return br1, br2

92

90

 

93

91

 

111

109

             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',

112

110

                          'b@u-0-3', 'b@u-0-4',

113

111

                          'b@u-0-5', 'a@u-0-5']),

114

 

             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-4',

 

112

             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',

115

113

                          'b@u-0-3', 'b@u-0-4',

116

114

                          'b@u-0-5', 'b@u-0-6']),

117

115

             ]

123

121

                    continue

124

122

                if rev_id in br2_only and not branch is br2:

125

123

                    continue

126

 

                self.assertThat(anc,

127

 

                    MatchesAncestry(branch.repository, rev_id))

 

124

                mutter('ancestry of {%s}: %r',

 

125

                       rev_id, branch.repository.get_ancestry(rev_id))

 

126

                result = sorted(branch.repository.get_ancestry(rev_id))

 

127

                self.assertEquals(result, [None] + sorted(anc))

 

128

    

 

129

    

 

130

    def test_is_ancestor(self):

 

131

        """Test checking whether a revision is an ancestor of another revision"""

 

132

        br1, br2 = make_branches(self)

 

133

        revisions = br1.revision_history()

 

134

        revisions_2 = br2.revision_history()

 

135

        sources = br1

 

136

 

 

137

        br1.lock_read()

 

138

        br2.lock_read()

 

139

        self.addCleanup(br1.unlock)

 

140

        br2.lock_read()

 

141

        self.addCleanup(br2.unlock)

 

142

 

 

143

        self.assertTrue(self.applyDeprecated(one_zero,

 

144

                        is_ancestor, revisions[0], revisions[0], br1))

 

145

        self.assertTrue(self.applyDeprecated(one_zero,

 

146

                        is_ancestor, revisions[1], revisions[0], sources))

 

147

        self.assertFalse(self.applyDeprecated(one_zero,

 

148

                         is_ancestor, revisions[0], revisions[1], sources))

 

149

        self.assertTrue(self.applyDeprecated(one_zero,

 

150

                        is_ancestor, revisions_2[3], revisions[0], sources))

 

151

        # disabled mbp 20050914, doesn't seem to happen anymore

 

152

        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],

 

153

        ##                  revisions[0], br1)

 

154

        self.assertTrue(self.applyDeprecated(one_zero,

 

155

                        is_ancestor, revisions[3], revisions_2[4], sources))

 

156

        self.assertTrue(self.applyDeprecated(one_zero,

 

157

                        is_ancestor, revisions[3], revisions_2[4], br1))

 

158

        self.assertTrue(self.applyDeprecated(one_zero,

 

159

                        is_ancestor, revisions[3], revisions_2[3], sources))

 

160

        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))

128

161

 

129

162

 

130

163

class TestIntermediateRevisions(TestCaseWithTransport):

144

177

        wt2.merge_from_branch(self.br1)

145

178

        wt2.commit("Commit fifteen", rev_id="b@u-0-10")

146

179

 

 

180

        from bzrlib.revision import MultipleRevisionSources

 

181

        self.sources = self.applyDeprecated(one_three,

 

182

                        MultipleRevisionSources, self.br1.repository,

 

183

                                                 self.br2.repository)

 

184

 

 

185

 

147

186

 

148

187

class MockRevisionSource(object):

149

188

    """A RevisionSource that takes a pregenerated graph.

163

202

class TestCommonAncestor(TestCaseWithTransport):

164

203

    """Test checking whether a revision is an ancestor of another revision"""

165

204

 

 

205

    def assertCommonAncestorEqual(self, expected, sources, rev_a, rev_b):

 

206

        self.assertEqual(expected,

 

207

                         self.applyDeprecated(one_three, 

 

208

                         common_ancestor, rev_a, rev_b, sources))

 

209

 

 

210

    def assertCommonAncestorIn(self, possible, sources, rev_a, rev_b):

 

211

        """assert that we pick one among multiple possible common ancestors"""

 

212

        self.assertTrue(self.applyDeprecated(one_three, 

 

213

                            common_ancestor, rev_a, rev_b, sources)

 

214

                        in possible)

 

215

 

 

216

    def test_common_ancestor(self):

 

217

        """Pick a reasonable merge base"""

 

218

        br1, br2 = make_branches(self)

 

219

        revisions = br1.revision_history()

 

220

        revisions_2 = br2.revision_history()

 

221

        sources = self.applyDeprecated(one_three, 

 

222

                    MultipleRevisionSources, br1.repository, br2.repository)

 

223

        expected_ancestors_list = {revisions[3]:(0, 0), 

 

224

                                   revisions[2]:(1, 1),

 

225

                                   revisions_2[4]:(2, 1), 

 

226

                                   revisions[1]:(3, 2),

 

227

                                   revisions_2[3]:(4, 2),

 

228

                                   revisions[0]:(5, 3) }

 

229

        ancestors_list = find_present_ancestors(revisions[3], sources)

 

230

        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))

 

231

        for key, value in expected_ancestors_list.iteritems():

 

232

            self.assertEqual(ancestors_list[key], value, 

 

233

                              "key %r, %r != %r" % (key, ancestors_list[key],

 

234

                                                    value))

 

235

        self.assertCommonAncestorEqual(revisions[0], sources,

 

236

                                       revisions[0], revisions[0])

 

237

        self.assertCommonAncestorEqual(revisions[1], sources,

 

238

                                       revisions[1], revisions[2])

 

239

        self.assertCommonAncestorEqual(revisions[1], sources,

 

240

                                       revisions[1], revisions[1])

 

241

        self.assertCommonAncestorEqual(revisions[2], sources,

 

242

                                       revisions[2], revisions_2[4])

 

243

        self.assertCommonAncestorEqual(revisions_2[4], sources,

 

244

                                       revisions[3], revisions_2[4])

 

245

        self.assertCommonAncestorEqual(revisions_2[4], sources,

 

246

                                       revisions[4], revisions_2[5])

 

247

        self.assertCommonAncestorIn((revisions[4], revisions_2[5]), sources,

 

248

                                     revisions[5], revisions_2[6])

 

249

        self.assertCommonAncestorIn((revisions[4], revisions_2[5]), sources,

 

250

                                     revisions_2[6], revisions[5])

 

251

        self.assertCommonAncestorEqual(None, sources,

 

252

                                       None, revisions[5])

 

253

        self.assertCommonAncestorEqual(NULL_REVISION, sources,

 

254

                                       NULL_REVISION, NULL_REVISION)

 

255

        self.assertCommonAncestorEqual(NULL_REVISION, sources,

 

256

                                       revisions[0], NULL_REVISION)

 

257

        self.assertCommonAncestorEqual(NULL_REVISION, sources,

 

258

                                       NULL_REVISION, revisions[0])

 

259

 

 

260

    def test_combined(self):

 

261

        """combined_graph

 

262

        Ensure it's not order-sensitive

 

263

        """

 

264

        br1, br2 = make_branches(self)

 

265

        source = self.applyDeprecated(one_three,

 

266

                    MultipleRevisionSources, br1.repository, br2.repository)

 

267

        combined_1 = self.applyDeprecated(one_three,

 

268

                        combined_graph, br1.last_revision(),

 

269

                                        br2.last_revision(), source)

 

270

        combined_2 = self.applyDeprecated(one_three,

 

271

                        combined_graph, br2.last_revision(),

 

272

                                        br1.last_revision(), source)

 

273

        self.assertEquals(combined_1[1], combined_2[1])

 

274

        self.assertEquals(combined_1[2], combined_2[2])

 

275

        self.assertEquals(combined_1[3], combined_2[3])

 

276

        self.assertEquals(combined_1, combined_2)

 

277

 

166

278

    def test_get_history(self):

167

279

        # TODO: test ghosts on the left hand branch's impact

168

280

        # TODO: test ghosts on all parents, we should get some

182

294

        history = rev.get_history(tree.branch.repository)

183

295

        self.assertEqual([None, '1', '2' ,'3'], history)

184

296

 

 

297

    def test_common_ancestor_rootless_graph(self):

 

298

        # common_ancestor on a graph with no reachable roots - only

 

299

        # ghosts - should still return a useful value.

 

300

        graph = Graph()

 

301

        # add a ghost node which would be a root if it wasn't a ghost.

 

302

        graph.add_ghost('a_ghost')

 

303

        # add a normal commit on top of that

 

304

        graph.add_node('rev1', ['a_ghost'])

 

305

        # add a left-branch revision

 

306

        graph.add_node('left', ['rev1'])

 

307

        # add a right-branch revision

 

308

        graph.add_node('right', ['rev1'])

 

309

        source = MockRevisionSource(graph)

 

310

        self.assertCommonAncestorEqual('rev1', source, 'left', 'right')

 

311

 

 

312

 

 

313

class TestMultipleRevisionSources(TestCaseWithTransport):

 

314

    """Tests for the MultipleRevisionSources adapter."""

 

315

 

 

316

    def test_get_revision_graph_merges_ghosts(self):

 

317

        # when we ask for the revision graph for B, which

 

318

        # is in repo 1 with a ghost of A, and which is not

 

319

        # in repo 2, which has A, the revision_graph()

 

320

        # should return A and B both.

 

321

        tree_1 = self.make_branch_and_tree('1')

 

322

        tree_1.set_parent_ids(['A'], allow_leftmost_as_ghost=True)

 

323

        tree_1.commit('foo', rev_id='B', allow_pointless=True)

 

324

        tree_2 = self.make_branch_and_tree('2')

 

325

        tree_2.commit('bar', rev_id='A', allow_pointless=True)

 

326

        source = self.applyDeprecated(one_three,

 

327

                    MultipleRevisionSources, tree_1.branch.repository,

 

328

                                             tree_2.branch.repository)

 

329

        # get_revision_graph calls the deprecated

 

330

        # get_revision_graph_with_ghosts once for each repository.

 

331

        expected_warning = symbol_versioning.deprecation_string(

 

332

            tree_1.branch.repository.get_revision_graph_with_ghosts,

 

333

            one_three)

 

334

        rev_graph = self.callDeprecated([expected_warning, expected_warning],

 

335

                        source.get_revision_graph, 'B')

 

336

        self.assertEqual({'B':['A'],

 

337

                          'A':[]}, rev_graph)

 

338

 

185

339

 

186

340

class TestReservedId(TestCase):

187

341

 

206

360

        self.assertEqual('a', r.get_summary())

207

361

        r.message = '\na\nb'

208

362

        self.assertEqual('a', r.get_summary())

209

 

        r.message = None

210

 

        self.assertEqual('', r.get_summary())

211

363

 

212

 

    def test_get_apparent_authors(self):

 

364

    def test_get_apparent_author(self):

213

365

        r = revision.Revision('1')

214

366

        r.committer = 'A'

215

 

        self.assertEqual(['A'], r.get_apparent_authors())

 

367

        self.assertEqual('A', r.get_apparent_author())

216

368

        r.properties['author'] = 'B'

217

 

        self.assertEqual(['B'], r.get_apparent_authors())

218

 

        r.properties['authors'] = 'C\nD'

219

 

        self.assertEqual(['C', 'D'], r.get_apparent_authors())

220

 

 

221

 

    def test_get_apparent_authors_no_committer(self):

222

 

        r = revision.Revision('1')

223

 

        self.assertEqual([], r.get_apparent_authors())

224

 

 

225

 

 

226

 

class TestRevisionBugs(TestCase):

227

 

    """Tests for getting the bugs that a revision is linked to."""

228

 

 

229

 

    def test_no_bugs(self):

230

 

        r = revision.Revision('1')

231

 

        self.assertEqual([], list(r.iter_bugs()))

232

 

 

233

 

    def test_some_bugs(self):

234

 

        r = revision.Revision(

235

 

            '1', properties={

236

 

                'bugs': bugtracker.encode_fixes_bug_urls(

237

 

                    ['http://example.com/bugs/1',

238

 

                     'http://launchpad.net/bugs/1234'])})

239

 

        self.assertEqual(

240

 

            [('http://example.com/bugs/1', bugtracker.FIXED),

241

 

             ('http://launchpad.net/bugs/1234', bugtracker.FIXED)],

242

 

            list(r.iter_bugs()))

243

 

 

244

 

    def test_no_status(self):

245

 

        r = revision.Revision(

246

 

            '1', properties={'bugs': 'http://example.com/bugs/1'})

247

 

        self.assertRaises(InvalidLineInBugsProperty, list, r.iter_bugs())

248

 

 

249

 

    def test_too_much_information(self):

250

 

        r = revision.Revision(

251

 

            '1', properties={'bugs': 'http://example.com/bugs/1 fixed bar'})

252

 

        self.assertRaises(InvalidLineInBugsProperty, list, r.iter_bugs())

253

 

 

254

 

    def test_invalid_status(self):

255

 

        r = revision.Revision(

256

 

            '1', properties={'bugs': 'http://example.com/bugs/1 faxed'})

257

 

        self.assertRaises(InvalidBugStatus, list, r.iter_bugs())

 

369

        self.assertEqual('B', r.get_apparent_author())

• Older »

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