~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_missing.py

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

• reverse the comparison (4665.6.1 to 3688.3.3)
• stop comparing with revision 3688.3.3

Show diffs side-by-side

added

removed

bzrlib/tests/test_missing.py

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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 

15

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

16

16

 

17

17

import os

18

18

 

30

30

 

31

31

class TestMissing(TestCaseWithTransport):

32

32

 

33

 

    def assertUnmerged(self, expected, source, target, restrict='all'):

34

 

        unmerged = missing.find_unmerged(source, target, restrict=restrict)

 

33

    def assertUnmerged(self, expected, source, target, restrict='all',

 

34

                       backward=False):

 

35

        unmerged = missing.find_unmerged(source, target, restrict=restrict,

 

36

                                         backward=backward)

35

37

        self.assertEqual(expected, unmerged)

36

 

            

 

38

 

37

39

    def test_find_unmerged(self):

38

40

        original_tree = self.make_branch_and_tree('original')

39

41

        original = original_tree.branch

43

45

        merger = merger_tree.branch

44

46

        self.assertUnmerged(([], []), original, puller)

45

47

        original_tree.commit('a', rev_id='a')

46

 

        self.assertUnmerged(([(1, 'a')], []), original, puller)

 

48

        self.assertUnmerged(([('1', 'a')], []), original, puller)

47

49

        puller_tree.pull(original)

48

50

        self.assertUnmerged(([], []), original, puller)

49

51

        merger_tree.pull(original)

50

52

        original_tree.commit('b', rev_id='b')

51

53

        original_tree.commit('c', rev_id='c')

52

 

        self.assertUnmerged(([(2, 'b'), (3, 'c')], []),

 

54

        self.assertUnmerged(([('2', 'b'), ('3', 'c')], []),

53

55

                            original, puller)

 

56

        self.assertUnmerged(([('3', 'c'), ('2', 'b')], []),

 

57

                            original, puller, backward=True)

54

58

 

55

59

        puller_tree.pull(original)

56

60

        self.assertUnmerged(([], []), original, puller)

57

 

        self.assertUnmerged(([(2, 'b'), (3, 'c')], []),

 

61

        self.assertUnmerged(([('2', 'b'), ('3', 'c')], []),

58

62

                            original, merger)

59

63

        merger_tree.merge_from_branch(original)

60

 

        self.assertUnmerged(([(2, 'b'), (3, 'c')], []),

 

64

        self.assertUnmerged(([('2', 'b'), ('3', 'c')], []),

61

65

                            original, merger)

62

66

        merger_tree.commit('d', rev_id='d')

63

 

        self.assertUnmerged(([], [(2, 'd')]), original, merger)

 

67

        self.assertUnmerged(([], [('2', 'd')]), original, merger)

64

68

 

65

69

    def test_iter_log_revisions(self):

66

70

        base_tree = self.make_branch_and_tree('base')

85

89

 

86

90

        base_extra, child_extra = missing.find_unmerged(base_tree.branch,

87

91

                                                        child_tree.branch)

88

 

        results = list(iter_log_revisions(base_extra, 

 

92

        results = list(iter_log_revisions(base_extra,

89

93

                            base_tree.branch.repository,

90

94

                            verbose=True))

91

95

        self.assertEqual([], results)

97

101

 

98

102

        r0,r1,r2,r3 = results

99

103

 

100

 

        self.assertEqual((2, 'c-2'), (r0.revno, r0.rev.revision_id))

101

 

        self.assertEqual((3, 'c-3'), (r1.revno, r1.rev.revision_id))

102

 

        self.assertEqual((4, 'c-4'), (r2.revno, r2.rev.revision_id))

103

 

        self.assertEqual((5, 'c-5'), (r3.revno, r3.rev.revision_id))

 

104

        self.assertEqual([('2', 'c-2'), ('3', 'c-3'),

 

105

                          ('4', 'c-4'), ('5', 'c-5'),],

 

106

                         [(r.revno, r.rev.revision_id) for r in results])

104

107

 

105

108

        delta0 = r0.delta

106

109

        self.assertNotEqual(None, delta0)

135

138

class TestFindUnmerged(tests.TestCaseWithTransport):

136

139

 

137

140

    def assertUnmerged(self, local, remote, local_branch, remote_branch,

138

 

                       restrict):

 

141

            restrict='all', include_merges=False, backward=False,

 

142

            local_revid_range=None, remote_revid_range=None):

139

143

        """Check the output of find_unmerged_mainline_revisions"""

140

144

        local_extra, remote_extra = missing.find_unmerged(

141

 

                                        local_branch, remote_branch, restrict)

 

145

            local_branch, remote_branch, restrict,

 

146

            include_merges=include_merges, backward=backward,

 

147

            local_revid_range=local_revid_range,

 

148

            remote_revid_range=remote_revid_range)

142

149

        self.assertEqual(local, local_extra)

143

150

        self.assertEqual(remote, remote_extra)

144

151

 

147

154

        rev1 = tree.commit('one')

148

155

        tree.lock_read()

149

156

        self.addCleanup(tree.unlock)

150

 

        self.assertUnmerged([], [], tree.branch, tree.branch, 'all')

 

157

        self.assertUnmerged([], [], tree.branch, tree.branch)

 

158

        self.assertUnmerged([], [], tree.branch, tree.branch,

 

159

            local_revid_range=(rev1, rev1))

151

160

 

152

161

    def test_one_ahead(self):

153

162

        tree = self.make_branch_and_tree('tree')

154

163

        rev1 = tree.commit('one')

155

164

        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()

156

165

        rev2 = tree2.commit('two')

157

 

        tree.lock_read()

158

 

        self.addCleanup(tree.unlock)

159

 

        tree2.lock_read()

160

 

        self.addCleanup(tree2.unlock)

161

 

        self.assertUnmerged([], [(2, rev2)], tree.branch, tree2.branch, 'all')

162

 

        self.assertUnmerged([(2, rev2)], [], tree2.branch, tree.branch, 'all')

 

166

        self.assertUnmerged([], [('2', rev2)], tree.branch, tree2.branch)

 

167

        self.assertUnmerged([('2', rev2)], [], tree2.branch, tree.branch)

163

168

 

164

169

    def test_restrict(self):

165

170

        tree = self.make_branch_and_tree('tree')

166

171

        rev1 = tree.commit('one')

167

172

        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()

168

173

        rev2 = tree2.commit('two')

169

 

        tree.lock_read()

170

 

        self.addCleanup(tree.unlock)

171

 

        tree2.lock_read()

172

 

        self.addCleanup(tree2.unlock)

173

 

        self.assertUnmerged([], [(2, rev2)], tree.branch, tree2.branch, 'all')

 

174

        self.assertUnmerged([], [('2', rev2)], tree.branch, tree2.branch)

174

175

        self.assertUnmerged([], None, tree.branch, tree2.branch, 'local')

175

 

        self.assertUnmerged(None, [(2, rev2)], tree.branch, tree2.branch,

 

176

        self.assertUnmerged(None, [('2', rev2)], tree.branch, tree2.branch,

176

177

                                               'remote')

177

178

 

178

179

    def test_merged(self):

184

185

        tree.merge_from_branch(tree2.branch)

185

186

        rev4 = tree.commit('four')

186

187

 

187

 

        tree.lock_read()

188

 

        self.addCleanup(tree.unlock)

189

 

        tree2.lock_read()

190

 

        self.addCleanup(tree2.unlock)

191

 

 

192

 

        self.assertUnmerged([(2, rev4)], [], tree.branch, tree2.branch, 'all')

 

188

        self.assertUnmerged([('2', rev4)], [], tree.branch, tree2.branch)

 

189

        self.assertUnmerged([('2', rev4)], [], tree.branch, tree2.branch,

 

190

            local_revid_range=(rev4, rev4))

 

191

        self.assertUnmerged([], [], tree.branch, tree2.branch,

 

192

            local_revid_range=(rev1, rev1))

 

193

 

 

194

    def test_include_merges(self):

 

195

        tree = self.make_branch_and_tree('tree')

 

196

        rev1 = tree.commit('one', rev_id='rev1')

 

197

 

 

198

        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()

 

199

        rev2 = tree2.commit('two', rev_id='rev2')

 

200

        rev3 = tree2.commit('three', rev_id='rev3')

 

201

 

 

202

        tree3 = tree2.bzrdir.sprout('tree3').open_workingtree()

 

203

        rev4 = tree3.commit('four', rev_id='rev4')

 

204

        rev5 = tree3.commit('five', rev_id='rev5')

 

205

 

 

206

        tree2.merge_from_branch(tree3.branch)

 

207

        rev6 = tree2.commit('six', rev_id='rev6')

 

208

 

 

209

        self.assertUnmerged([], [('2', 'rev2', 0), ('3', 'rev3', 0),

 

210

                                 ('4', 'rev6', 0),

 

211

                                 ('3.1.1', 'rev4', 1), ('3.1.2', 'rev5', 1),

 

212

                                 ],

 

213

                            tree.branch, tree2.branch,

 

214

                            include_merges=True)

 

215

 

 

216

        self.assertUnmerged([], [('4', 'rev6', 0),

 

217

                                 ('3.1.2', 'rev5', 1), ('3.1.1', 'rev4', 1),

 

218

                                 ('3', 'rev3', 0), ('2', 'rev2', 0),

 

219

                                 ],

 

220

                            tree.branch, tree2.branch,

 

221

                            include_merges=True,

 

222

                            backward=True)

 

223

 

 

224

        self.assertUnmerged([], [('4', 'rev6', 0)],

 

225

            tree.branch, tree2.branch,

 

226

            include_merges=True, remote_revid_range=(rev6, rev6))

 

227

 

 

228

        self.assertUnmerged([], [('3', 'rev3', 0), ('3.1.1', 'rev4', 1)],

 

229

                    tree.branch, tree2.branch,

 

230

                    include_merges=True, remote_revid_range=(rev3, rev4))

 

231

 

 

232

        self.assertUnmerged([], [('4', 'rev6', 0), ('3.1.2', 'rev5', 1)],

 

233

                    tree.branch, tree2.branch,

 

234

                    include_merges=True, remote_revid_range=(rev5, rev6))

 

235

 

 

236

    def test_revision_range(self):

 

237

        local = self.make_branch_and_tree('local')

 

238

        lrevid1 = local.commit('one')

 

239

        remote = local.bzrdir.sprout('remote').open_workingtree()

 

240

        rrevid2 = remote.commit('two')

 

241

        rrevid3 = remote.commit('three')

 

242

        rrevid4 = remote.commit('four')

 

243

        lrevid2 = local.commit('two')

 

244

        lrevid3 = local.commit('three')

 

245

        lrevid4 = local.commit('four')

 

246

        local_extra = [('2', lrevid2), ('3', lrevid3), ('4', lrevid4)]

 

247

        remote_extra = [('2', rrevid2), ('3', rrevid3), ('4', rrevid4)]

 

248

 

 

249

        # control

 

250

        self.assertUnmerged(local_extra, remote_extra,

 

251

            local.branch, remote.branch)

 

252

        self.assertUnmerged(local_extra, remote_extra,

 

253

            local.branch, remote.branch, local_revid_range=(None, None),

 

254

            remote_revid_range=(None, None))

 

255

 

 

256

        # exclude local revisions

 

257

        self.assertUnmerged([('2', lrevid2)], remote_extra,

 

258

            local.branch, remote.branch, local_revid_range=(lrevid2, lrevid2))

 

259

        self.assertUnmerged([('2', lrevid2), ('3', lrevid3)], remote_extra,

 

260

            local.branch, remote.branch, local_revid_range=(lrevid2, lrevid3))

 

261

        self.assertUnmerged([('2', lrevid2), ('3', lrevid3)], None,

 

262

            local.branch, remote.branch, 'local',

 

263

            local_revid_range=(lrevid2, lrevid3))

 

264

 

 

265

        # exclude remote revisions

 

266

        self.assertUnmerged(local_extra, [('2', rrevid2)],

 

267

            local.branch, remote.branch, remote_revid_range=(None, rrevid2))

 

268

        self.assertUnmerged(local_extra, [('2', rrevid2)],

 

269

            local.branch, remote.branch, remote_revid_range=(lrevid1, rrevid2))

 

270

        self.assertUnmerged(local_extra, [('2', rrevid2)],

 

271

            local.branch, remote.branch, remote_revid_range=(rrevid2, rrevid2))

 

272

        self.assertUnmerged(local_extra, [('2', rrevid2), ('3', rrevid3)],

 

273

            local.branch, remote.branch, remote_revid_range=(None, rrevid3))

 

274

        self.assertUnmerged(local_extra, [('2', rrevid2), ('3', rrevid3)],

 

275

            local.branch, remote.branch, remote_revid_range=(rrevid2, rrevid3))

 

276

        self.assertUnmerged(local_extra, [('3', rrevid3)],

 

277

            local.branch, remote.branch, remote_revid_range=(rrevid3, rrevid3))

 

278

        self.assertUnmerged(None, [('2', rrevid2), ('3', rrevid3)],

 

279

            local.branch, remote.branch, 'remote',

 

280

            remote_revid_range=(rrevid2, rrevid3))

 

281

 

 

282

        # exclude local and remote revisions

 

283

        self.assertUnmerged([('3', lrevid3)], [('3', rrevid3)],

 

284

            local.branch, remote.branch, local_revid_range=(lrevid3, lrevid3),

 

285

            remote_revid_range=(rrevid3, rrevid3))

• Older »

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