~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_missing.py

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

• reverse the comparison (5462.5.1 to 6617)
• stop comparing with revision 6617

Show diffs side-by-side

added

removed

bzrlib/tests/blackbox/test_missing.py

1

 

# Copyright (C) 2005-2012, 2016 Canonical Ltd

 

1

# Copyright (C) 2005-2010 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

16

16

 

17

17

"""Black-box tests for bzr missing."""

18

18

 

19

 

from bzrlib import (

20

 

    osutils,

21

 

    tests,

22

 

    )

23

 

 

24

 

 

25

 

class TestMissing(tests.TestCaseWithTransport):

 

19

import os

 

20

 

 

21

from bzrlib import osutils

 

22

 

 

23

from bzrlib.branch import Branch

 

24

from bzrlib.tests import TestCaseWithTransport

 

25

 

 

26

 

 

27

class TestMissing(TestCaseWithTransport):

26

28

 

27

29

    def assertMessages(self, out, must_have=(), must_not_have=()):

28

30

        """Check if commit messages are in or not in the output"""

47

49

        self.assertEqual('', err)

48

50

 

49

51

    def test_missing(self):

50

 

        missing_one = "You are missing 1 revision:"

51

 

        extra_one = "You have 1 extra revision:"

 

52

        missing = "You are missing 1 revision(s):"

52

53

 

53

54

        # create a source branch

54

55

        a_tree = self.make_branch_and_tree('a')

61

62

        self.build_tree_contents([('b/a', 'initial\nmore\n')])

62

63

        b_tree.commit(message='more')

63

64

 

64

 

        def run_missing(args, retcode=1, working_dir=None):

65

 

            out, err = self.run_bzr(['missing'] + args,

66

 

                                    retcode=retcode, working_dir=working_dir)

67

 

            # we do not expect any error output.

68

 

            self.assertEqual('', err)

69

 

            return out.splitlines()

70

 

 

71

 

        def run_missing_a(args, retcode=1):

72

 

            return run_missing(['../a'] + args,

73

 

                               retcode=retcode, working_dir='b')

74

 

 

75

 

        def run_missing_b(args, retcode=1):

76

 

            return run_missing(['../b'] + args,

77

 

                               retcode=retcode, working_dir='a')

78

 

 

79

65

        # run missing in a against b

80

66

        # this should not require missing to take out a write lock on a

81

67

        # or b. So we take a write lock on both to test that at the same

86

72

        a_branch.lock_write()

87

73

        b_branch = b_tree.branch

88

74

        b_branch.lock_write()

89

 

 

90

 

        lines = run_missing_b([])

 

75

        os.chdir('a')

 

76

        out,err = self.run_bzr('missing ../b', retcode=1)

 

77

        lines = out.splitlines()

91

78

        # we're missing the extra revision here

92

 

        self.assertEqual(missing_one, lines[0])

 

79

        self.assertEqual(missing, lines[0])

93

80

        # and we expect 8 lines of output which we trust at the moment to be

94

81

        # good.

95

82

        self.assertEqual(8, len(lines))

 

83

        # we do not expect any error output.

 

84

        self.assertEqual('', err)

96

85

        # unlock the branches for the rest of the test

97

86

        a_branch.unlock()

98

87

        b_branch.unlock()

102

91

        a_tree.commit(message='merge')

103

92

 

104

93

        # compare again, but now we have the 'merge' commit extra

105

 

        lines = run_missing_b([])

106

 

        self.assertEqual(extra_one, lines[0])

107

 

        self.assertLength(8, lines)

108

 

 

109

 

        lines2 = run_missing_b(['--mine-only'])

 

94

        lines = self.run_bzr('missing ../b', retcode=1)[0].splitlines()

 

95

        self.assertEqual("You have 1 extra revision(s):", lines[0])

 

96

        self.assertEqual(8, len(lines))

 

97

        lines2 = self.run_bzr('missing ../b --mine-only', retcode=1)[0]

 

98

        lines2 = lines2.splitlines()

110

99

        self.assertEqual(lines, lines2)

111

 

 

112

 

        lines3 = run_missing_b(['--theirs-only'], retcode=0)

113

 

        self.assertEqualDiff('Other branch has no new revisions.', lines3[0])

 

100

        lines3 = self.run_bzr('missing ../b --theirs-only', retcode=0)[0]

 

101

        self.assertEqualDiff('Other branch is up to date.\n', lines3)

114

102

 

115

103

        # relative to a, missing the 'merge' commit

116

 

        lines = run_missing_a([])

117

 

        self.assertEqual(missing_one, lines[0])

118

 

        self.assertLength(8, lines)

119

 

 

120

 

        lines2 = run_missing_a(['--theirs-only'])

 

104

        os.chdir('../b')

 

105

        lines = self.run_bzr('missing ../a', retcode=1)[0].splitlines()

 

106

        self.assertEqual(missing, lines[0])

 

107

        self.assertEqual(8, len(lines))

 

108

        lines2 = self.run_bzr('missing ../a --theirs-only', retcode=1)[0]

 

109

        lines2 = lines2.splitlines()

121

110

        self.assertEqual(lines, lines2)

122

 

 

123

 

        lines3 = run_missing_a(['--mine-only'], retcode=0)

124

 

        self.assertEqualDiff('This branch has no new revisions.', lines3[0])

125

 

 

126

 

        lines4 = run_missing_a(['--short'])

127

 

        self.assertLength(4, lines4)

128

 

 

129

 

        lines4a = run_missing_a(['-S'])

130

 

        self.assertEqual(lines4, lines4a)

131

 

 

132

 

        lines5 = run_missing_a(['--line'])

133

 

        self.assertLength(2, lines5)

134

 

 

135

 

        lines6 = run_missing_a(['--reverse'])

 

111

        lines3 = self.run_bzr('missing ../a --mine-only', retcode=0)[0]

 

112

        self.assertEqualDiff('This branch is up to date.\n', lines3)

 

113

        lines4 = self.run_bzr('missing ../a --short', retcode=1)[0]

 

114

        lines4 = lines4.splitlines()

 

115

        self.assertEqual(4, len(lines4))

 

116

        lines5 = self.run_bzr('missing ../a --line', retcode=1)[0]

 

117

        lines5 = lines5.splitlines()

 

118

        self.assertEqual(2, len(lines5))

 

119

        lines6 = self.run_bzr('missing ../a --reverse', retcode=1)[0]

 

120

        lines6 = lines6.splitlines()

136

121

        self.assertEqual(lines6, lines)

137

 

 

138

 

        lines7 = run_missing_a(['--show-ids'])

139

 

        self.assertLength(11, lines7)

140

 

 

141

 

        lines8 =  run_missing_a(['--verbose'])

 

122

        lines7 = self.run_bzr('missing ../a --show-ids', retcode=1)[0]

 

123

        lines7 = lines7.splitlines()

 

124

        self.assertEqual(11, len(lines7))

 

125

        lines8 = self.run_bzr('missing ../a --verbose', retcode=1)[0]

 

126

        lines8 = lines8.splitlines()

142

127

        self.assertEqual("modified:", lines8[-2])

143

128

        self.assertEqual("  a", lines8[-1])

144

129

 

145

 

        self.assertEqualDiff('Other branch has no new revisions.',

146

 

                             run_missing_b(['--theirs-only'], retcode=0)[0])

 

130

        os.chdir('../a')

 

131

        self.assertEqualDiff('Other branch is up to date.\n',

 

132

                             self.run_bzr('missing ../b --theirs-only')[0])

147

133

 

148

134

        # after a pull we're back on track

149

135

        b_tree.pull(a_branch)

150

 

        self.assertEqualDiff("Branches are up to date.",

151

 

                             run_missing_b([], retcode=0)[0])

152

 

        self.assertEqualDiff('Branches are up to date.',

153

 

                             run_missing_a([], retcode=0)[0])

 

136

        self.assertEqualDiff("Branches are up to date.\n",

 

137

                             self.run_bzr('missing ../b')[0])

 

138

        os.chdir('../b')

 

139

        self.assertEqualDiff('Branches are up to date.\n',

 

140

                             self.run_bzr('missing ../a')[0])

154

141

        # If you supply mine or theirs you only know one side is up to date

155

 

        self.assertEqualDiff('This branch has no new revisions.',

156

 

                             run_missing_a(['--mine-only'], retcode=0)[0])

157

 

        self.assertEqualDiff('Other branch has no new revisions.',

158

 

                              run_missing_a(['--theirs-only'], retcode=0)[0])

 

142

        self.assertEqualDiff('This branch is up to date.\n',

 

143

                             self.run_bzr('missing ../a --mine-only')[0])

 

144

        self.assertEqualDiff('Other branch is up to date.\n',

 

145

                             self.run_bzr('missing ../a --theirs-only')[0])

159

146

 

160

147

    def test_missing_filtered(self):

161

148

        # create a source branch

170

157

            a_tree.commit(message='a%d' % i)

171

158

            b_tree.commit(message='b%d' % i)

172

159

 

 

160

        os.chdir('a')

173

161

        # local

174

 

        out,err = self.run_bzr('missing ../b --my-revision 3',

175

 

                               retcode=1, working_dir='a')

 

162

        out,err = self.run_bzr('missing ../b --my-revision 3', retcode=1)

176

163

        self.assertMessages(out, ('a3', 'b2', 'b3', 'b4', 'b5'), ('a2', 'a4'))

177

164

 

178

 

        out,err = self.run_bzr('missing ../b --my-revision 3..4',

179

 

                               retcode=1, working_dir='a')

 

165

        out,err = self.run_bzr('missing ../b --my-revision 3..4', retcode=1)

180

166

        self.assertMessages(out, ('a3', 'a4'), ('a2', 'a5'))

181

167

 

182

168

        #remote

183

 

        out,err = self.run_bzr('missing ../b -r 3',

184

 

                               retcode=1, working_dir='a')

 

169

        out,err = self.run_bzr('missing ../b -r 3', retcode=1)

185

170

        self.assertMessages(out, ('a2', 'a3', 'a4', 'a5', 'b3'), ('b2', 'b4'))

186

171

 

187

 

        out,err = self.run_bzr('missing ../b -r 3..4',

188

 

                               retcode=1, working_dir='a')

 

172

        out,err = self.run_bzr('missing ../b -r 3..4', retcode=1)

189

173

        self.assertMessages(out, ('b3', 'b4'), ('b2', 'b5'))

190

174

 

191

175

        #both

192

176

        out,err = self.run_bzr('missing ../b --my-revision 3..4 -r 3..4',

193

 

                               retcode=1, working_dir='a')

 

177

            retcode=1)

194

178

        self.assertMessages(out, ('a3', 'a4', 'b3', 'b4'),

195

179

            ('a2', 'a5', 'b2', 'b5'))

196

180

 

204

188

        wt.add('foo')

205

189

        wt.commit('initial')

206

190

 

207

 

        location = osutils.getcwd() + '/a/'

 

191

        os.chdir('a')

 

192

        location = osutils.getcwd() + '/'

208

193

 

209

194

        # clone

210

 

        b.bzrdir.sprout('b')

 

195

        b.bzrdir.sprout('../b')

211

196

 

212

197

        # check last location

213

 

        lines, err = self.run_bzr('missing', working_dir='b')

214

 

        self.assertEqual('Using saved parent location: %s\n'

215

 

                         'Branches are up to date.\n' % location,

216

 

                         lines)

217

 

        self.assertEqual('', err)

 

198

        lines, err = self.run_bzr('missing', working_dir='../b')

 

199

        self.assertEquals('Using saved parent location: %s\n'

 

200

                          'Branches are up to date.\n' % location,

 

201

                          lines)

 

202

        self.assertEquals('', err)

218

203

 

219

204

    def test_missing_directory(self):

220

205

        """Test --directory option"""

229

214

        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()

230

215

        self.build_tree_contents([('b/a', 'initial\nmore\n')])

231

216

        b_tree.commit(message='more')

232

 

 

 

217

        

233

218

        out2, err2 = self.run_bzr('missing --directory a b', retcode=1)

234

 

        out1, err1 = self.run_bzr('missing ../b', retcode=1, working_dir='a')

 

219

        os.chdir('a')

 

220

        out1, err1 = self.run_bzr('missing ../b', retcode=1)

235

221

        self.assertEqualDiff(out1, out2)

236

222

        self.assertEqualDiff(err1, err2)

237

 

 

238

 

    def test_missing_tags(self):

239

 

        """Test showing tags"""

240

 

 

241

 

        # create a source branch

242

 

        a_tree = self.make_branch_and_tree('a')

243

 

        self.build_tree_contents([('a/a', 'initial\n')])

244

 

        a_tree.add('a')

245

 

        a_tree.commit(message='initial')

246

 

 

247

 

        # clone and add a differing revision

248

 

        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()

249

 

        self.build_tree_contents([('b/a', 'initial\nmore\n')])

250

 

        b_tree.commit(message='more')

251

 

        b_tree.branch.tags.set_tag('a-tag', b_tree.last_revision())

252

 

 

253

 

        for log_format in ['long', 'short', 'line']:

254

 

            out, err = self.run_bzr(

255

 

                'missing --log-format={0} ../a'.format(log_format),

256

 

                working_dir='b', retcode=1)

257

 

            self.assertContainsString(out, 'a-tag')

258

 

 

259

 

            out, err = self.run_bzr(

260

 

                'missing --log-format={0} ../b'.format(log_format),

261

 

                working_dir='a', retcode=1)

262

 

            self.assertContainsString(out, 'a-tag')

• Older »

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