~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_version_info.py

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

• reverse the comparison (2022.1.1 to 5200.3.1)
• stop comparing with revision 5200.3.1

Show diffs side-by-side

added

removed

bzrlib/tests/test_version_info.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 

15

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

16

16

 

17

17

"""Tests for version_info"""

18

18

 

21

21

import os

22

22

import sys

23

23

 

24

 

from bzrlib import (

25

 

    errors,

26

 

    registry,

27

 

    symbol_versioning,

28

 

    tests,

29

 

    version_info_formats,

30

 

    )

31

 

from bzrlib.tests import TestCaseWithTransport

 

24

from bzrlib.tests import TestCase, TestCaseWithTransport

 

25

from bzrlib.branch import Branch

32

26

from bzrlib.rio import read_stanzas

33

27

 

34

 

from bzrlib.version_info_formats.format_custom import CustomVersionInfoBuilder

 

28

# TODO: jam 20051228 When part of bzrlib, this should become

 

29

#       from bzrlib.generate_version_info import foo

 

30

 

35

31

from bzrlib.version_info_formats.format_rio import RioVersionInfoBuilder

36

32

from bzrlib.version_info_formats.format_python import PythonVersionInfoBuilder

37

33

 

49

45

        wt.add('b')

50

46

        wt.commit('b', rev_id='r2')

51

47

 

52

 

        self.build_tree_contents([('branch/a', 'new contents\n')])

53

 

        wt.commit(u'\xe52', rev_id='r3')

 

48

        open('branch/a', 'wb').write('new contents\n')

 

49

        wt.commit('a2', rev_id='r3')

54

50

 

55

51

        return wt

56

52

 

57

 

    def test_rio_null(self):

58

 

        wt = self.make_branch_and_tree('branch')

59

 

 

60

 

        sio = StringIO()

61

 

        builder = RioVersionInfoBuilder(wt.branch, working_tree=wt)

62

 

        builder.generate(sio)

63

 

        val = sio.getvalue()

64

 

        self.assertContainsRe(val, 'build-date:')

65

 

        self.assertContainsRe(val, 'revno: 0')

66

 

 

67

53

    def test_rio_version_text(self):

68

54

        wt = self.create_branch()

69

55

 

95

81

        self.assertContainsRe(val, 'id: r2')

96

82

        self.assertContainsRe(val, 'message: b')

97

83

        self.assertContainsRe(val, 'id: r3')

98

 

        self.assertContainsRe(val, 'message: \xc3\xa52') # utf8 encoding '\xe5'

99

 

 

100

 

    def test_rio_version_hook(self):

101

 

        def update_stanza(rev, stanza):

102

 

            stanza.add('bla', 'bloe')

103

 

        RioVersionInfoBuilder.hooks.install_named_hook(

104

 

            'revision', update_stanza, None)

105

 

        wt = self.create_branch()

106

 

 

107

 

        def regen(**kwargs):

108

 

            sio = StringIO()

109

 

            builder = RioVersionInfoBuilder(wt.branch, working_tree=wt,

110

 

                                            **kwargs)

111

 

            builder.generate(sio)

112

 

            sio.seek(0)

113

 

            stanzas = list(read_stanzas(sio))

114

 

            self.assertEqual(1, len(stanzas))

115

 

            return stanzas[0]

116

 

 

117

 

        stanza = regen()

118

 

        self.assertEqual(['bloe'], stanza.get_all('bla'))

 

84

        self.assertContainsRe(val, 'message: a2')

119

85

 

120

86

    def test_rio_version(self):

121

87

        wt = self.create_branch()

149

115

        stanza = regen(check_for_clean=True, include_file_revisions=True)

150

116

        self.assertEqual(['False'], stanza.get_all('clean'))

151

117

 

152

 

        # This assumes it's being run against a tree that does not update the

153

 

        # root revision on every commit.

154

118

        file_rev_stanza = get_one_stanza(stanza, 'file-revisions')

155

 

        self.assertEqual(['', 'a', 'b', 'c'], file_rev_stanza.get_all('path'))

156

 

        self.assertEqual(['r1', 'r3', 'r2', 'unversioned'],

 

119

        self.assertEqual(['a', 'b', 'c'], file_rev_stanza.get_all('path'))

 

120

        self.assertEqual(['r3', 'r2', 'unversioned'],

157

121

            file_rev_stanza.get_all('revision'))

158

122

        os.remove('branch/c')

159

123

 

160

124

        stanza = regen(include_revision_history=True)

161

125

        revision_stanza = get_one_stanza(stanza, 'revisions')

162

126

        self.assertEqual(['r1', 'r2', 'r3'], revision_stanza.get_all('id'))

163

 

        self.assertEqual(['a', 'b', u'\xe52'], revision_stanza.get_all('message'))

 

127

        self.assertEqual(['a', 'b', 'a2'], revision_stanza.get_all('message'))

164

128

        self.assertEqual(3, len(revision_stanza.get_all('date')))

165

129

 

166

130

        # a was modified, so it should show up modified again

169

133

        wt.rename_one('b', 'd')

170

134

        stanza = regen(check_for_clean=True, include_file_revisions=True)

171

135

        file_rev_stanza = get_one_stanza(stanza, 'file-revisions')

172

 

        self.assertEqual(['', 'a', 'b', 'c', 'd'],

173

 

                          file_rev_stanza.get_all('path'))

174

 

        self.assertEqual(['r1', 'modified', 'renamed to d', 'new',

175

 

                          'renamed from b'],

 

136

        self.assertEqual(['a', 'b', 'c', 'd'], file_rev_stanza.get_all('path'))

 

137

        self.assertEqual(['modified', 'renamed to d', 'new', 'renamed from b'],

176

138

                         file_rev_stanza.get_all('revision'))

177

139

 

178

140

        wt.commit('modified', rev_id='r4')

180

142

        os.remove('branch/d')

181

143

        stanza = regen(check_for_clean=True, include_file_revisions=True)

182

144

        file_rev_stanza = get_one_stanza(stanza, 'file-revisions')

183

 

        self.assertEqual(['', 'a', 'c', 'd'], file_rev_stanza.get_all('path'))

184

 

        self.assertEqual(['r1', 'r4', 'unversioned', 'removed'],

 

145

        self.assertEqual(['a', 'c', 'd'], file_rev_stanza.get_all('path'))

 

146

        self.assertEqual(['r4', 'unversioned', 'removed'],

185

147

                         file_rev_stanza.get_all('revision'))

186

148

 

187

 

    def test_python_null(self):

188

 

        wt = self.make_branch_and_tree('branch')

189

 

 

190

 

        sio = StringIO()

191

 

        builder = PythonVersionInfoBuilder(wt.branch, working_tree=wt)

192

 

        builder.generate(sio)

193

 

        val = sio.getvalue()

194

 

        self.assertContainsRe(val, "'revision_id': None")

195

 

        self.assertContainsRe(val, "'revno': 0")

196

 

 

197

149

    def test_python_version(self):

198

150

        wt = self.create_branch()

199

151

 

200

152

        def regen(**kwargs):

201

 

            """Create a test module, import and return it"""

202

153

            outf = open('test_version_information.py', 'wb')

203

 

            try:

204

 

                builder = PythonVersionInfoBuilder(wt.branch, working_tree=wt,

205

 

                                                   **kwargs)

206

 

                builder.generate(outf)

207

 

            finally:

208

 

                outf.close()

 

154

            builder = PythonVersionInfoBuilder(wt.branch, working_tree=wt,

 

155

                                               **kwargs)

 

156

            builder.generate(outf)

 

157

            outf.close()

209

158

            module_info = imp.find_module('test_version_information',

210

159

                                          [os.getcwdu()])

211

160

            tvi = imp.load_module('tvi', *module_info)

234

183

        self.build_tree(['branch/c'])

235

184

        tvi = regen(check_for_clean=True, include_file_revisions=True)

236

185

        self.assertEqual(False, tvi.version_info['clean'])

237

 

        self.assertEqual(['', 'a', 'b', 'c'],

238

 

                         sorted(tvi.file_revisions.keys()))

 

186

        self.assertEqual(['a', 'b', 'c'], sorted(tvi.file_revisions.keys()))

239

187

        self.assertEqual('r3', tvi.file_revisions['a'])

240

188

        self.assertEqual('r2', tvi.file_revisions['b'])

241

189

        self.assertEqual('unversioned', tvi.file_revisions['c'])

245

193

 

246

194

        rev_info = [(rev, message) for rev, message, timestamp, timezone

247

195

                                   in tvi.revisions]

248

 

        self.assertEqual([('r1', 'a'), ('r2', 'b'), ('r3', u'\xe52')], rev_info)

 

196

        self.assertEqual([('r1', 'a'), ('r2', 'b'), ('r3', 'a2')], rev_info)

249

197

 

250

198

        # a was modified, so it should show up modified again

251

199

        self.build_tree(['branch/a', 'branch/c'])

252

200

        wt.add('c')

253

201

        wt.rename_one('b', 'd')

254

202

        tvi = regen(check_for_clean=True, include_file_revisions=True)

255

 

        self.assertEqual(['', 'a', 'b', 'c', 'd'],

256

 

                          sorted(tvi.file_revisions.keys()))

 

203

        self.assertEqual(['a', 'b', 'c', 'd'], sorted(tvi.file_revisions.keys()))

257

204

        self.assertEqual('modified', tvi.file_revisions['a'])

258

205

        self.assertEqual('renamed to d', tvi.file_revisions['b'])

259

206

        self.assertEqual('new', tvi.file_revisions['c'])

263

210

        wt.remove(['c', 'd'])

264

211

        os.remove('branch/d')

265

212

        tvi = regen(check_for_clean=True, include_file_revisions=True)

266

 

        self.assertEqual(['', 'a', 'c', 'd'],

267

 

                          sorted(tvi.file_revisions.keys()))

 

213

        self.assertEqual(['a', 'c', 'd'], sorted(tvi.file_revisions.keys()))

268

214

        self.assertEqual('r4', tvi.file_revisions['a'])

269

215

        self.assertEqual('unversioned', tvi.file_revisions['c'])

270

216

        self.assertEqual('removed', tvi.file_revisions['d'])

271

217

 

272

 

    def test_custom_null(self):

273

 

        sio = StringIO()

274

 

        wt = self.make_branch_and_tree('branch')

275

 

        builder = CustomVersionInfoBuilder(wt.branch, working_tree=wt,

276

 

            template='revno: {revno}')

277

 

        builder.generate(sio)

278

 

        self.assertEquals("revno: 0", sio.getvalue())

279

 

 

280

 

        builder = CustomVersionInfoBuilder(wt.branch, working_tree=wt, 

281

 

            template='{revno} revid: {revision_id}')

282

 

        # revision_id is not available yet

283

 

        self.assertRaises(errors.MissingTemplateVariable, 

284

 

            builder.generate, sio)

285

 

 

286

 

    def test_custom_version_text(self):

287

 

        wt = self.create_branch()

288

 

 

289

 

        def regen(tpl, **kwargs):

290

 

            sio = StringIO()

291

 

            builder = CustomVersionInfoBuilder(wt.branch, working_tree=wt,

292

 

                                               template=tpl, **kwargs)

293

 

            builder.generate(sio)

294

 

            val = sio.getvalue()

295

 

            return val

296

 

 

297

 

        val = regen('build-date: "{build_date}"\ndate: "{date}"')

298

 

        self.assertContainsRe(val, 'build-date: "[0-9-+: ]+"')

299

 

        self.assertContainsRe(val, 'date: "[0-9-+: ]+"')

300

 

 

301

 

        val = regen('revno: {revno}')

302

 

        self.assertEqual(val, 'revno: 3')

303

 

 

304

 

        val = regen('revision-id: {revision_id}')

305

 

        self.assertEqual(val, 'revision-id: r3')

306

 

 

307

 

        val = regen('clean: {clean}', check_for_clean=True)

308

 

        self.assertEqual(val, 'clean: 1')

309

 

 

310

 

        self.build_tree(['branch/c'])

311

 

        val = regen('clean: {clean}', check_for_clean=True)

312

 

        self.assertEqual(val, 'clean: 0')

313

 

        os.remove('branch/c')

314

 

 

315

 

    def test_custom_without_template(self):

316

 

        builder = CustomVersionInfoBuilder(None)

317

 

        sio = StringIO()

318

 

        self.assertRaises(errors.NoTemplate, builder.generate, sio)

319

 

 

320

 

 

321

 

class TestBuilder(version_info_formats.VersionInfoBuilder):

322

 

    pass

323

 

 

324

 

 

325

 

class TestVersionInfoFormatRegistry(tests.TestCase):

326

 

 

327

 

    def setUp(self):

328

 

        super(TestVersionInfoFormatRegistry, self).setUp()

329

 

        self.overrideAttr(version_info_formats,

330

 

                          'format_registry', registry.Registry())

331

 

 

332

 

    def test_register_remove(self):

333

 

        registry = version_info_formats.format_registry

334

 

        registry.register('testbuilder',

335

 

            TestBuilder, 'a simple test builder')

336

 

        self.assertIs(TestBuilder, registry.get('testbuilder'))

337

 

        self.assertEqual('a simple test builder',

338

 

                         registry.get_help('testbuilder'))

339

 

        registry.remove('testbuilder')

340

 

        self.assertRaises(KeyError, registry.get, 'testbuilder')

 

218

 

• Older »

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