~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_ui.py

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

• reverse the comparison (4801 to 4964)
• stop comparing with revision 4964

Show diffs side-by-side

added

removed

bzrlib/tests/test_ui.py

18

18

"""

19

19

 

20

20

import os

 

21

from StringIO import StringIO

21

22

import re

 

23

import sys

22

24

import time

23

25

 

24

26

from bzrlib import (

29

31

from bzrlib.symbol_versioning import (

30

32

    deprecated_in,

31

33

    )

32

 

from bzrlib.tests import test_progress

33

 

from bzrlib.ui import text as _mod_ui_text

 

34

from bzrlib.tests import (

 

35

    TestCase,

 

36

    TestUIFactory,

 

37

    StringIOWrapper,

 

38

    )

 

39

from bzrlib.tests.test_progress import (

 

40

    _NonTTYStringIO,

 

41

    _TTYStringIO,

 

42

    )

 

43

from bzrlib.ui import (

 

44

    CannedInputUIFactory,

 

45

    SilentUIFactory,

 

46

    UIFactory,

 

47

    make_ui_for_terminal,

 

48

    )

 

49

from bzrlib.ui.text import (

 

50

    NullProgressView,

 

51

    TextProgressView,

 

52

    TextUIFactory,

 

53

    )

34

54

 

35

55

 

36

56

class TestTextUIFactory(tests.TestCase):

80

100

            pb.finished()

81

101

 

82

102

    def test_progress_note(self):

83

 

        stderr = tests.StringIOWrapper()

84

 

        stdout = tests.StringIOWrapper()

85

 

        ui_factory = _mod_ui_text.TextUIFactory(stdin=tests.StringIOWrapper(''),

86

 

                                                stderr=stderr,

87

 

                                                stdout=stdout)

 

103

        stderr = StringIO()

 

104

        stdout = StringIO()

 

105

        ui_factory = TextUIFactory(stdin=StringIO(''),

 

106

            stderr=stderr,

 

107

            stdout=stdout)

88

108

        pb = ui_factory.nested_progress_bar()

89

109

        try:

90

110

            result = self.applyDeprecated(deprecated_in((2, 1, 0)),

100

120

            pb.finished()

101

121

 

102

122

    def test_progress_note_clears(self):

103

 

        stderr = test_progress._TTYStringIO()

104

 

        stdout = test_progress._TTYStringIO()

 

123

        stderr = _TTYStringIO()

 

124

        stdout = _TTYStringIO()

105

125

        # so that we get a TextProgressBar

106

126

        os.environ['TERM'] = 'xterm'

107

 

        ui_factory = _mod_ui_text.TextUIFactory(

108

 

            stdin=tests.StringIOWrapper(''),

 

127

        ui_factory = TextUIFactory(

 

128

            stdin=StringIO(''),

109

129

            stdout=stdout, stderr=stderr)

110

130

        self.assertIsInstance(ui_factory._progress_view,

111

 

                              _mod_ui_text.TextProgressView)

 

131

            TextProgressView)

112

132

        pb = ui_factory.nested_progress_bar()

113

133

        try:

114

134

            # Create a progress update that isn't throttled

126

146

 

127

147

    def test_progress_nested(self):

128

148

        # test factory based nested and popping.

129

 

        ui = _mod_ui_text.TextUIFactory(None, None, None)

 

149

        ui = TextUIFactory(None, None, None)

130

150

        pb1 = ui.nested_progress_bar()

131

151

        pb2 = ui.nested_progress_bar()

132

152

        # You do get a warning if the outermost progress bar wasn't finished

139

159

        pb1.finished()

140

160

 

141

161

    def test_text_ui_get_boolean(self):

142

 

        stdin = tests.StringIOWrapper("y\n" # True

143

 

                                      "n\n" # False

144

 

                                      "yes with garbage\nY\n" # True

145

 

                                      "not an answer\nno\n" # False

146

 

                                      "I'm sure!\nyes\n" # True

147

 

                                      "NO\n" # False

148

 

                                      "foo\n")

149

 

        stdout = tests.StringIOWrapper()

150

 

        stderr = tests.StringIOWrapper()

151

 

        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)

 

162

        stdin = StringIO("y\n" # True

 

163

                         "n\n" # False

 

164

                         "yes with garbage\nY\n" # True

 

165

                         "not an answer\nno\n" # False

 

166

                         "I'm sure!\nyes\n" # True

 

167

                         "NO\n" # False

 

168

                         "foo\n")

 

169

        stdout = StringIO()

 

170

        stderr = StringIO()

 

171

        factory = TextUIFactory(stdin, stdout, stderr)

152

172

        self.assertEqual(True, factory.get_boolean(""))

153

173

        self.assertEqual(False, factory.get_boolean(""))

154

174

        self.assertEqual(True, factory.get_boolean(""))

159

179

        # stdin should be empty

160

180

        self.assertEqual('', factory.stdin.readline())

161

181

 

162

 

    def test_text_ui_get_integer(self):

163

 

        stdin = tests.StringIOWrapper(

164

 

            "1\n"

165

 

            "  -2  \n"

166

 

            "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n")

167

 

        stdout = tests.StringIOWrapper()

168

 

        stderr = tests.StringIOWrapper()

169

 

        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)

170

 

        self.assertEqual(1, factory.get_integer(""))

171

 

        self.assertEqual(-2, factory.get_integer(""))

172

 

        self.assertEqual(42, factory.get_integer(""))

173

 

 

174

182

    def test_text_factory_prompt(self):

175

183

        # see <https://launchpad.net/bugs/365891>

176

 

        StringIO = tests.StringIOWrapper

177

 

        factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO())

 

184

        factory = TextUIFactory(StringIO(), StringIO(), StringIO())

178

185

        factory.prompt('foo %2e')

179

186

        self.assertEqual('', factory.stdout.getvalue())

180

187

        self.assertEqual('foo %2e', factory.stderr.getvalue())

181

188

 

182

189

    def test_text_factory_prompts_and_clears(self):

183

190

        # a get_boolean call should clear the pb before prompting

184

 

        out = test_progress._TTYStringIO()

 

191

        out = _TTYStringIO()

185

192

        os.environ['TERM'] = 'xterm'

186

 

        factory = _mod_ui_text.TextUIFactory(

187

 

            stdin=tests.StringIOWrapper("yada\ny\n"),

188

 

            stdout=out, stderr=out)

 

193

        factory = TextUIFactory(stdin=StringIO("yada\ny\n"), stdout=out, stderr=out)

189

194

        pb = factory.nested_progress_bar()

190

195

        pb.show_bar = False

191

196

        pb.show_spinner = False

205

210

        self.assertEqual('', factory.stdin.readline())

206

211

 

207

212

    def test_text_tick_after_update(self):

208

 

        ui_factory = _mod_ui_text.TextUIFactory(stdout=tests.StringIOWrapper(),

209

 

                                                stderr=tests.StringIOWrapper())

 

213

        ui_factory = TextUIFactory(stdout=StringIO(), stderr=StringIO())

210

214

        pb = ui_factory.nested_progress_bar()

211

215

        try:

212

216

            pb.update('task', 0, 3)

217

221

            pb.finished()

218

222

 

219

223

    def test_text_ui_getusername(self):

220

 

        factory = _mod_ui_text.TextUIFactory(None, None, None)

221

 

        factory.stdin = tests.StringIOWrapper("someuser\n\n")

222

 

        factory.stdout = tests.StringIOWrapper()

223

 

        factory.stderr = tests.StringIOWrapper()

 

224

        factory = TextUIFactory(None, None, None)

 

225

        factory.stdin = StringIO("someuser\n\n")

 

226

        factory.stdout = StringIO()

 

227

        factory.stderr = StringIO()

224

228

        factory.stdout.encoding = "utf8"

225

229

        # there is no output from the base factory

226

230

        self.assertEqual("someuser",

249

253

            pb.finished()

250

254

 

251

255

 

252

 

class TestTextUIOutputStream(tests.TestCase):

253

 

    """Tests for output stream that synchronizes with progress bar."""

254

 

 

255

 

    def test_output_clears_terminal(self):

256

 

        stdout = tests.StringIOWrapper()

257

 

        stderr = tests.StringIOWrapper()

258

 

        clear_calls = []

259

 

 

260

 

        uif =  _mod_ui_text.TextUIFactory(None, stdout, stderr)

261

 

        uif.clear_term = lambda: clear_calls.append('clear')

262

 

 

263

 

        stream = _mod_ui_text.TextUIOutputStream(uif, uif.stdout)

264

 

        stream.write("Hello world!\n")

265

 

        stream.write("there's more...\n")

266

 

        stream.writelines(["1\n", "2\n", "3\n"])

267

 

 

268

 

        self.assertEqual(stdout.getvalue(),

269

 

            "Hello world!\n"

270

 

            "there's more...\n"

271

 

            "1\n2\n3\n")

272

 

        self.assertEqual(['clear', 'clear', 'clear'],

273

 

            clear_calls)

274

 

 

275

 

        stream.flush()

276

 

 

277

 

 

278

256

class UITests(tests.TestCase):

279

257

 

280

258

    def test_progress_construction(self):

281

259

        """TextUIFactory constructs the right progress view.

282

260

        """

283

 

        TTYStringIO = test_progress._TTYStringIO

284

 

        FileStringIO = tests.StringIOWrapper

285

261

        for (file_class, term, pb, expected_pb_class) in (

286

262

            # on an xterm, either use them or not as the user requests,

287

263

            # otherwise default on

288

 

            (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),

289

 

            (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),

290

 

            (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),

 

264

            (_TTYStringIO, 'xterm', 'none', NullProgressView),

 

265

            (_TTYStringIO, 'xterm', 'text', TextProgressView),

 

266

            (_TTYStringIO, 'xterm', None, TextProgressView),

291

267

            # on a dumb terminal, again if there's explicit configuration do

292

268

            # it, otherwise default off

293

 

            (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),

294

 

            (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),

295

 

            (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),

 

269

            (_TTYStringIO, 'dumb', 'none', NullProgressView),

 

270

            (_TTYStringIO, 'dumb', 'text', TextProgressView),

 

271

            (_TTYStringIO, 'dumb', None, NullProgressView),

296

272

            # on a non-tty terminal, it's null regardless of $TERM

297

 

            (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),

298

 

            (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),

 

273

            (StringIO, 'xterm', None, NullProgressView),

 

274

            (StringIO, 'dumb', None, NullProgressView),

299

275

            # however, it can still be forced on

300

 

            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),

 

276

            (StringIO, 'dumb', 'text', TextProgressView),

301

277

            ):

302

278

            os.environ['TERM'] = term

303

279

            if pb is None:

308

284

            stdin = file_class('')

309

285

            stderr = file_class()

310

286

            stdout = file_class()

311

 

            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)

312

 

            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,

 

287

            uif = make_ui_for_terminal(stdin, stdout, stderr)

 

288

            self.assertIsInstance(uif, TextUIFactory,

313

289

                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))

314

290

            self.assertIsInstance(uif.make_progress_view(),

315

291

                expected_pb_class,

317

293

 

318

294

    def test_text_ui_non_terminal(self):

319

295

        """Even on non-ttys, make_ui_for_terminal gives a text ui."""

320

 

        stdin = test_progress._NonTTYStringIO('')

321

 

        stderr = test_progress._NonTTYStringIO()

322

 

        stdout = test_progress._NonTTYStringIO()

 

296

        stdin = _NonTTYStringIO('')

 

297

        stderr = _NonTTYStringIO()

 

298

        stdout = _NonTTYStringIO()

323

299

        for term_type in ['dumb', None, 'xterm']:

324

300

            if term_type is None:

325

301

                del os.environ['TERM']

326

302

            else:

327

303

                os.environ['TERM'] = term_type

328

 

            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)

329

 

            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,

 

304

            uif = make_ui_for_terminal(stdin, stdout, stderr)

 

305

            self.assertIsInstance(uif, TextUIFactory,

330

306

                'TERM=%r' % (term_type,))

331

307

 

332

308

 

333

 

class SilentUITests(tests.TestCase):

 

309

class SilentUITests(TestCase):

334

310

 

335

311

    def test_silent_factory_get_password(self):

336

312

        # A silent factory that can't do user interaction can't get a

337

313

        # password.  Possibly it should raise a more specific error but it

338

314

        # can't succeed.

339

 

        ui = _mod_ui.SilentUIFactory()

340

 

        stdout = tests.StringIOWrapper()

 

315

        ui = SilentUIFactory()

 

316

        stdout = StringIO()

341

317

        self.assertRaises(

342

318

            NotImplementedError,

343

319

            self.apply_redirected,

346

322

        self.assertEqual('', stdout.getvalue())

347

323

 

348

324

    def test_silent_ui_getbool(self):

349

 

        factory = _mod_ui.SilentUIFactory()

350

 

        stdout = tests.StringIOWrapper()

 

325

        factory = SilentUIFactory()

 

326

        stdout = StringIO()

351

327

        self.assertRaises(

352

328

            NotImplementedError,

353

329

            self.apply_redirected,

354

330

            None, stdout, stdout, factory.get_boolean, "foo")

355

331

 

356

332

 

357

 

class TestUIFactoryTests(tests.TestCase):

 

333

class TestUIFactoryTests(TestCase):

358

334

 

359

335

    def test_test_ui_factory_progress(self):

360

336

        # there's no output; we just want to make sure this doesn't crash -

361

337

        # see https://bugs.edge.launchpad.net/bzr/+bug/408201

362

 

        ui = tests.TestUIFactory()

 

338

        ui = TestUIFactory()

363

339

        pb = ui.nested_progress_bar()

364

340

        pb.update('hello')

365

341

        pb.tick()

366

342

        pb.finished()

367

343

 

368

344

 

369

 

class CannedInputUIFactoryTests(tests.TestCase):

370

 

 

 

345

class CannedInputUIFactoryTests(TestCase):

 

346

    

371

347

    def test_canned_input_get_input(self):

372

 

        uif = _mod_ui.CannedInputUIFactory([True, 'mbp', 'password', 42])

373

 

        self.assertEqual(True, uif.get_boolean('Extra cheese?'))

374

 

        self.assertEqual('mbp', uif.get_username('Enter your user name'))

375

 

        self.assertEqual('password',

376

 

                         uif.get_password('Password for %(host)s',

377

 

                                          host='example.com'))

378

 

        self.assertEqual(42, uif.get_integer('And all that jazz ?'))

 

348

        uif = CannedInputUIFactory([True, 'mbp', 'password'])

 

349

        self.assertEqual(uif.get_boolean('Extra cheese?'), True)

 

350

        self.assertEqual(uif.get_username('Enter your user name'), 'mbp')

 

351

        self.assertEqual(uif.get_password('Password for %(host)s', host='example.com'),

 

352

            'password')

379

353

 

380

354

 

381

355

class TestBoolFromString(tests.TestCase):

• Older »

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