~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

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

Show diffs side-by-side

added

removed

bzrlib/tests/blackbox/test_status.py

1

 

# Copyright (C) 2005, 2006 by Canonical Ltd

 

1

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

24

24

 

25

25

from cStringIO import StringIO

26

26

import codecs

27

 

from os import mkdir, chdir

 

27

from os import mkdir, chdir, rmdir, unlink

28

28

import sys

29

29

from tempfile import TemporaryFile

30

30

 

40

40

 

41

41

class BranchStatus(TestCaseWithTransport):

42

42

    

43

 

    def assertStatus(self, output_lines, working_tree,

44

 

        revision=None):

 

43

    def assertStatus(self, expected_lines, working_tree,

 

44

        revision=None, short=False):

45

45

        """Run status in working_tree and look for output.

46

46

        

47

 

        :param output_lines: The lines to look for.

 

47

        :param expected_lines: The lines to look for.

48

48

        :param working_tree: The tree to run status in.

49

49

        """

50

 

        output_string = self.status_string(working_tree, revision)

51

 

        self.assertEqual(output_lines, output_string.splitlines(True))

 

50

        output_string = self.status_string(working_tree, revision, short)

 

51

        self.assertEqual(expected_lines, output_string.splitlines(True))

52

52

    

53

 

    def status_string(self, wt, revision=None):

 

53

    def status_string(self, wt, revision=None, short=False):

54

54

        # use a real file rather than StringIO because it doesn't handle

55

55

        # Unicode very well.

56

56

        tof = codecs.getwriter('utf-8')(TemporaryFile())

57

 

        show_tree_status(wt, to_file=tof, revision=revision)

 

57

        show_tree_status(wt, to_file=tof, revision=revision, short=short)

58

58

        tof.seek(0)

59

59

        return tof.read().decode('utf-8')

60

60

 

75

75

                '  hello.c\n',

76

76

            ],

77

77

            wt)

 

78

        self.assertStatus([

 

79

                '?   bye.c\n',

 

80

                '?   hello.c\n',

 

81

            ],

 

82

            wt, short=True)

78

83

 

79

84

        # add a commit to allow showing pending merges.

80

85

        wt.commit('create a parent to allow testing merge output')

88

93

                '  pending@pending-0-0\n',

89

94

            ],

90

95

            wt)

 

96

        self.assertStatus([

 

97

                '?   bye.c\n',

 

98

                '?   hello.c\n',

 

99

                'P   pending@pending-0-0\n',

 

100

            ],

 

101

            wt, short=True)

91

102

 

92

103

    def test_branch_status_revisions(self):

93

104

        """Tests branch status with revisions"""

132

143

        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")

133

144

        merge(["./branch", -1], [None, None], this_dir = './copy')

134

145

        message = self.status_string(wt2)

135

 

        self.assert_(message.startswith("pending merges:\n"))

136

 

        self.assert_(message.endswith("Empty commit 2\n")) 

 

146

        self.assertStartsWith(message, "pending merges:\n")

 

147

        self.assertEndsWith(message, "Empty commit 2\n")

137

148

        wt2.commit("merged")

138

149

        # must be long to make sure we see elipsis at the end

139

 

        wt.commit("Empty commit 3 " + 

140

 

                   "blah blah blah blah " * 10)

 

150

        wt.commit("Empty commit 3 " +

 

151

                   "blah blah blah blah " * 100)

141

152

        merge(["./branch", -1], [None, None], this_dir = './copy')

142

153

        message = self.status_string(wt2)

143

 

        self.assert_(message.startswith("pending merges:\n"))

 

154

        self.assertStartsWith(message, "pending merges:\n")

144

155

        self.assert_("Empty commit 3" in message)

145

 

        self.assert_(message.endswith("...\n")) 

146

 

 

147

 

    def test_branch_status_specific_files(self): 

 

156

        self.assertEndsWith(message, "...\n")

 

157

 

 

158

    def test_tree_status_ignores(self):

 

159

        """Tests branch status with ignores"""

 

160

        wt = self.make_branch_and_tree('.')

 

161

        self.run_bzr('ignore', '*~')

 

162

        wt.commit('commit .bzrignore')

 

163

        self.build_tree(['foo.c', 'foo.c~'])

 

164

        self.assertStatus([

 

165

                'unknown:\n',

 

166

                '  foo.c\n',

 

167

                ],

 

168

                wt)

 

169

        self.assertStatus([

 

170

                '?   foo.c\n',

 

171

                ],

 

172

                wt, short=True)

 

173

 

 

174

    def test_tree_status_specific_files(self):

148

175

        """Tests branch status with given specific files"""

149

176

        wt = self.make_branch_and_tree('.')

150

177

        b = wt.branch

154

181

        wt.add('test.c')

155

182

        wt.commit('testing')

156

183

        

 

184

        self.assertStatus([

 

185

                'unknown:\n',

 

186

                '  bye.c\n',

 

187

                '  dir2/\n',

 

188

                '  directory/hello.c\n'

 

189

                ],

 

190

                wt)

 

191

 

 

192

        self.assertStatus([

 

193

                '?   bye.c\n',

 

194

                '?   dir2/\n',

 

195

                '?   directory/hello.c\n'

 

196

                ],

 

197

                wt, short=True)

 

198

 

157

199

        tof = StringIO()

158

 

        show_tree_status(wt, to_file=tof)

159

 

        tof.seek(0)

160

 

        self.assertEquals(tof.readlines(),

161

 

                          ['unknown:\n',

162

 

                           '  bye.c\n',

163

 

                           '  dir2\n',

164

 

                           '  directory/hello.c\n'

165

 

                           ])

166

 

 

167

200

        self.assertRaises(errors.PathsDoNotExist,

168

201

                          show_tree_status,

169

202

                          wt, specific_files=['bye.c','test.c','absent.c'], 

177

210

                           '  directory/hello.c\n'

178

211

                           ])

179

212

        tof = StringIO()

 

213

        show_tree_status(wt, specific_files=['directory'], to_file=tof,

 

214

                         short=True)

 

215

        tof.seek(0)

 

216

        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])

 

217

 

 

218

        tof = StringIO()

180

219

        show_tree_status(wt, specific_files=['dir2'], to_file=tof)

181

220

        tof.seek(0)

182

221

        self.assertEquals(tof.readlines(),

183

222

                          ['unknown:\n',

184

 

                           '  dir2\n'

 

223

                           '  dir2/\n'

185

224

                           ])

 

225

        tof = StringIO()

 

226

        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)

 

227

        tof.seek(0)

 

228

        self.assertEquals(tof.readlines(), ['?   dir2/\n'])

186

229

 

187

230

    def test_status_nonexistent_file(self):

188

231

        # files that don't exist in either the basis tree or working tree

191

234

        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)

192

235

        self.assertContainsRe(err, r'do not exist.*does-not-exist')

193

236

 

 

237

    def test_status_out_of_date(self):

 

238

        """Simulate status of out-of-date tree after remote push"""

 

239

        tree = self.make_branch_and_tree('.')

 

240

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

 

241

        tree.lock_write()

 

242

        try:

 

243

            tree.add(['a'])

 

244

            tree.commit('add test file')

 

245

            # simulate what happens after a remote push

 

246

            tree.set_last_revision("0")

 

247

        finally:

 

248

            # before run another commands we should unlock tree

 

249

            tree.unlock()

 

250

        out, err = self.run_bzr('status')

 

251

        self.assertEqual("working tree is out of date, run 'bzr update'\n",

 

252

                         err)

 

253

 

194

254

 

195

255

class CheckoutStatus(BranchStatus):

196

256

 

208

268

 

209

269

class TestStatus(TestCaseWithTransport):

210

270

 

211

 

    def test_status(self):

 

271

    def test_status_plain(self):

212

272

        self.run_bzr("init")

 

273

 

213

274

        self.build_tree(['hello.txt'])

214

275

        result = self.run_bzr("status")[0]

215

 

        self.assert_("unknown:\n  hello.txt\n" in result, result)

 

276

        self.assertContainsRe(result, "unknown:\n  hello.txt\n")

 

277

 

216

278

        self.run_bzr("add", "hello.txt")

217

279

        result = self.run_bzr("status")[0]

218

 

        self.assert_("added:\n  hello.txt\n" in result, result)

 

280

        self.assertContainsRe(result, "added:\n  hello.txt\n")

 

281

 

219

282

        self.run_bzr("commit", "-m", "added")

220

283

        result = self.run_bzr("status", "-r", "0..1")[0]

221

 

        self.assert_("added:\n  hello.txt\n" in result, result)

 

284

        self.assertContainsRe(result, "added:\n  hello.txt\n")

 

285

 

222

286

        self.build_tree(['world.txt'])

223

287

        result = self.run_bzr("status", "-r", "0")[0]

224

 

        self.assert_("added:\n  hello.txt\n" \

225

 

                     "unknown:\n  world.txt\n" in result, result)

226

 

 

 

288

        self.assertContainsRe(result, "added:\n  hello.txt\n" \

 

289

                                      "unknown:\n  world.txt\n")

227

290

        result2 = self.run_bzr("status", "-r", "0..")[0]

228

291

        self.assertEquals(result2, result)

229

292

 

 

293

    def test_status_short(self):

 

294

        self.run_bzr("init")

 

295

 

 

296

        self.build_tree(['hello.txt'])

 

297

        result = self.run_bzr("status","--short")[0]

 

298

        self.assertContainsRe(result, "[?]   hello.txt\n")

 

299

 

 

300

        self.run_bzr("add", "hello.txt")

 

301

        result = self.run_bzr("status","--short")[0]

 

302

        self.assertContainsRe(result, "[+]N  hello.txt\n")

 

303

 

 

304

        self.run_bzr("commit", "-m", "added")

 

305

        result = self.run_bzr("status", "--short", "-r", "0..1")[0]

 

306

        self.assertContainsRe(result, "[+]N  hello.txt\n")

 

307

 

 

308

        self.build_tree(['world.txt'])

 

309

        result = self.run_bzr("status", "--short", "-r", "0")[0]

 

310

        self.assertContainsRe(result, "[+]N  hello.txt\n" \

 

311

                                      "[?]   world.txt\n")

 

312

        result2 = self.run_bzr("status", "--short", "-r", "0..")[0]

 

313

        self.assertEquals(result2, result)

 

314

 

 

315

    def test_status_versioned(self):

 

316

        self.run_bzr("init")

 

317

 

 

318

        self.build_tree(['hello.txt'])

 

319

        result = self.run_bzr("status", "--versioned")[0]

 

320

        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")

 

321

 

 

322

        self.run_bzr("add", "hello.txt")

 

323

        result = self.run_bzr("status", "--versioned")[0]

 

324

        self.assertContainsRe(result, "added:\n  hello.txt\n")

 

325

 

 

326

        self.run_bzr("commit", "-m", "added")

 

327

        result = self.run_bzr("status", "--versioned", "-r", "0..1")[0]

 

328

        self.assertContainsRe(result, "added:\n  hello.txt\n")

 

329

 

 

330

        self.build_tree(['world.txt'])

 

331

        result = self.run_bzr("status", "--versioned", "-r", "0")[0]

 

332

        self.assertContainsRe(result, "added:\n  hello.txt\n")

 

333

        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")

 

334

        result2 = self.run_bzr("status", "--versioned", "-r", "0..")[0]

 

335

        self.assertEquals(result2, result)

 

336

 

 

337

    def assertStatusContains(self, pattern):

 

338

        """Run status, and assert it contains the given pattern"""

 

339

        result = self.run_bzr("status", "--short")[0]

 

340

        self.assertContainsRe(result, pattern)

 

341

 

 

342

    def test_kind_change_short(self):

 

343

        tree = self.make_branch_and_tree('.')

 

344

        self.build_tree(['file'])

 

345

        tree.add('file')

 

346

        tree.commit('added file')

 

347

        unlink('file')

 

348

        self.build_tree(['file/'])

 

349

        self.assertStatusContains('K  file => file/')

 

350

        tree.rename_one('file', 'directory')

 

351

        self.assertStatusContains('RK  file => directory/')

 

352

        rmdir('directory')

 

353

        self.assertStatusContains('RD  file => directory')

 

354

 

230

355

 

231

356

class TestStatusEncodings(TestCaseWithTransport):

232

357

    

• Older »

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