~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_ui.py

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

• reverse the comparison (6015.59.1 to 6593)
• stop comparing with revision 6593

Show diffs side-by-side

added

removed

bzrlib/tests/test_ui.py

31

31

    )

32

32

from bzrlib.tests import (

33

33

    fixtures,

 

34

    test_progress,

34

35

    )

35

36

from bzrlib.ui import text as _mod_ui_text

36

37

from bzrlib.tests.testui import (

38

39

    )

39

40

 

40

41

 

41

 

class TTYStringIO(StringIO):

42

 

    """A helper class which makes a StringIO look like a terminal"""

43

 

 

44

 

    def isatty(self):

45

 

        return True

46

 

 

47

 

 

48

 

class NonTTYStringIO(StringIO):

49

 

    """Helper that implements isatty() but returns False"""

50

 

 

51

 

    def isatty(self):

52

 

        return False

53

 

 

54

 

 

55

42

class TestUIConfiguration(tests.TestCaseWithTransport):

56

43

 

57

44

    def test_output_encoding_configuration(self):

58

45

        enc = fixtures.generate_unicode_encodings().next()

59

 

        config.GlobalStack().set('output_encoding', enc)

 

46

        config.GlobalConfig().set_user_option('output_encoding',

 

47

            enc)

60

48

        ui = tests.TestUIFactory(stdin=None,

61

49

            stdout=tests.StringIOWrapper(),

62

50

            stderr=tests.StringIOWrapper())

97

85

            pb.finished()

98

86

 

99

87

    def test_text_factory_utf8_password(self):

100

 

        """Test an utf8 password."""

101

 

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

102

 

        ui.stdin = tests.StringIOWrapper(u'baz\u1234'.encode('utf8'))

103

 

        ui.stdout = tests.StringIOWrapper()

104

 

        ui.stderr = tests.StringIOWrapper()

 

88

        """Test an utf8 password.

 

89

 

 

90

        We can't predict what encoding users will have for stdin, so we force

 

91

        it to utf8 to test that we transport the password correctly.

 

92

        """

 

93

        ui = self.make_test_ui_factory(u'baz\u1234'.encode('utf8'))

105

94

        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'

106

 

        password = ui.get_password(u'Hello \u1234 %(user)s', user=u'some\u1234')

107

 

        self.assertEqual(u'baz\u1234', password)

108

 

        self.assertEqual(u'Hello \u1234 some\u1234: ',

109

 

                         ui.stderr.getvalue().decode('utf8'))

110

 

        # stdin and stdout should be empty

111

 

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

112

 

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

 

95

        pb = ui.nested_progress_bar()

 

96

        try:

 

97

            password = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr,

 

98

                                             ui.get_password,

 

99

                                             u'Hello \u1234 %(user)s',

 

100

                                             user=u'some\u1234')

 

101

            # We use StringIO objects, we need to decode them

 

102

            self.assertEqual(u'baz\u1234', password.decode('utf8'))

 

103

            self.assertEqual(u'Hello \u1234 some\u1234: ',

 

104

                             ui.stderr.getvalue().decode('utf8'))

 

105

            # stdin and stdout should be empty

 

106

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

 

107

            self.assertEqual('', ui.stdout.readline())

 

108

        finally:

 

109

            pb.finished()

113

110

 

114

111

    def test_text_ui_get_boolean(self):

115

112

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

116

113

                                      "n\n" # False

117

 

                                      " \n y \n" # True

118

 

                                      " no \n" # False

119

114

                                      "yes with garbage\nY\n" # True

120

115

                                      "not an answer\nno\n" # False

121

116

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

130

125

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

131

126

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

132

127

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

133

 

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

134

 

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

135

 

        self.assertEqual("foo\n", factory.stdin.read())

136

 

        # stdin should be empty

137

 

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

138

 

        # return false on EOF

139

 

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

140

 

 

141

 

    def test_text_ui_choose_bad_parameters(self):

142

 

        stdin = tests.StringIOWrapper()

143

 

        stdout = tests.StringIOWrapper()

144

 

        stderr = tests.StringIOWrapper()

145

 

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

146

 

        # invalid default index

147

 

        self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)

148

 

        # duplicated choice

149

 

        self.assertRaises(ValueError, factory.choose, u"", u"&choice\n&ChOiCe")

150

 

        # duplicated shortcut

151

 

        self.assertRaises(ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")

152

 

 

153

 

    def test_text_ui_choose_prompt(self):

154

 

        stdin = tests.StringIOWrapper()

155

 

        stdout = tests.StringIOWrapper()

156

 

        stderr = tests.StringIOWrapper()

157

 

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

158

 

        # choices with explicit shortcuts

159

 

        factory.choose(u"prompt", u"&yes\n&No\nmore &info")

160

 

        self.assertEqual("prompt ([y]es, [N]o, more [i]nfo): \n", factory.stderr.getvalue())

161

 

        # automatic shortcuts

162

 

        factory.stderr.truncate(0)

163

 

        factory.choose(u"prompt", u"yes\nNo\nmore info")

164

 

        self.assertEqual("prompt ([y]es, [N]o, [m]ore info): \n", factory.stderr.getvalue())

165

 

 

166

 

    def test_text_ui_choose_return_values(self):

167

 

        choose = lambda: factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)

168

 

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

169

 

                                      "n\n" # 1

170

 

                                      " \n" # default: 3

171

 

                                      " no \n" # 1

172

 

                                      "b\na\nd \n" # bad shortcuts, all ignored

173

 

                                      "yes with garbage\nY\n" # 0

174

 

                                      "not an answer\nno\n" # 1

175

 

                                      "info\nmore info\n" # 3

176

 

                                      "Maybe\n" # 2

177

 

                                      "foo\n")

178

 

        stdout = tests.StringIOWrapper()

179

 

        stderr = tests.StringIOWrapper()

180

 

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

181

 

        self.assertEqual(0, choose())

182

 

        self.assertEqual(1, choose())

183

 

        self.assertEqual(3, choose())

184

 

        self.assertEqual(1, choose())

185

 

        self.assertEqual(0, choose())

186

 

        self.assertEqual(1, choose())

187

 

        self.assertEqual(3, choose())

188

 

        self.assertEqual(2, choose())

189

 

        self.assertEqual("foo\n", factory.stdin.read())

190

 

        # stdin should be empty

191

 

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

192

 

        # return None on EOF

193

 

        self.assertEqual(None, choose())

194

 

 

195

 

    def test_text_ui_choose_no_default(self):

196

 

        stdin = tests.StringIOWrapper(" \n" # no default, invalid!

197

 

                                      " yes \n" # 0

198

 

                                      "foo\n")

199

 

        stdout = tests.StringIOWrapper()

200

 

        stderr = tests.StringIOWrapper()

201

 

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

202

 

        self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))

203

 

        self.assertEqual("foo\n", factory.stdin.read())

 

128

        self.assertEqual("foo\n", factory.stdin.read())

 

129

        # stdin should be empty

 

130

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

204

131

 

205

132

    def test_text_ui_get_integer(self):

206

133

        stdin = tests.StringIOWrapper(

224

151

 

225

152

    def test_text_factory_prompts_and_clears(self):

226

153

        # a get_boolean call should clear the pb before prompting

227

 

        out = TTYStringIO()

 

154

        out = test_progress._TTYStringIO()

228

155

        self.overrideEnv('TERM', 'xterm')

229

156

        factory = _mod_ui_text.TextUIFactory(

230

157

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

243

170

        output = out.getvalue()

244

171

        self.assertContainsRe(output,

245

172

            "| foo *\r\r  *\r*")

246

 

        self.assertContainsString(output,

247

 

            r"what do you want? ([y]es, [n]o): what do you want? ([y]es, [n]o): ")

 

173

        self.assertContainsRe(output,

 

174

            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")

248

175

        # stdin should have been totally consumed

249

176

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

250

177

 

261

188

            pb.finished()

262

189

 

263

190

    def test_text_ui_getusername(self):

264

 

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

265

 

        ui.stdin = tests.StringIOWrapper('someuser\n\n')

266

 

        ui.stdout = tests.StringIOWrapper()

267

 

        ui.stderr = tests.StringIOWrapper()

268

 

        ui.stdout.encoding = 'utf8'

269

 

        self.assertEqual('someuser',

270

 

                         ui.get_username(u'Hello %(host)s', host='some'))

271

 

        self.assertEquals('Hello some: ', ui.stderr.getvalue())

272

 

        self.assertEquals('', ui.stdout.getvalue())

273

 

        self.assertEqual('', ui.get_username(u"Gebruiker"))

 

191

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

 

192

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

 

193

        factory.stdout = tests.StringIOWrapper()

 

194

        factory.stderr = tests.StringIOWrapper()

 

195

        factory.stdout.encoding = "utf8"

 

196

        # there is no output from the base factory

 

197

        self.assertEqual("someuser",

 

198

                         factory.get_username(u'Hello %(host)s', host='some'))

 

199

        self.assertEquals("Hello some: ", factory.stderr.getvalue())

 

200

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

 

201

        self.assertEqual("", factory.get_username(u"Gebruiker"))

274

202

        # stdin should be empty

275

 

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

 

203

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

276

204

 

277

205

    def test_text_ui_getusername_utf8(self):

278

 

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

279

 

        ui.stdin = tests.StringIOWrapper(u'someuser\u1234'.encode('utf8'))

280

 

        ui.stdout = tests.StringIOWrapper()

281

 

        ui.stderr = tests.StringIOWrapper()

 

206

        ui = tests.TestUIFactory(stdin=u'someuser\u1234'.encode('utf8'),

 

207

                                 stdout=tests.StringIOWrapper(),

 

208

                                 stderr=tests.StringIOWrapper())

282

209

        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = "utf8"

283

 

        username = ui.get_username(u'Hello %(host)s', host=u'some\u1234')

284

 

        self.assertEquals(u"someuser\u1234", username)

285

 

        self.assertEquals(u"Hello some\u1234: ",

286

 

                          ui.stderr.getvalue().decode("utf8"))

287

 

        self.assertEquals('', ui.stdout.getvalue())

 

210

        pb = ui.nested_progress_bar()

 

211

        try:

 

212

            # there is no output from the base factory

 

213

            username = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr,

 

214

                ui.get_username, u'Hello\u1234 %(host)s', host=u'some\u1234')

 

215

            self.assertEquals(u"someuser\u1234", username.decode('utf8'))

 

216

            self.assertEquals(u"Hello\u1234 some\u1234: ",

 

217

                              ui.stderr.getvalue().decode("utf8"))

 

218

            self.assertEquals('', ui.stdout.getvalue())

 

219

        finally:

 

220

            pb.finished()

288

221

 

289

222

    def test_quietness(self):

290

223

        self.overrideEnv('BZR_PROGRESS_BAR', 'text')

291

224

        ui_factory = _mod_ui_text.TextUIFactory(None,

292

 

            TTYStringIO(),

293

 

            TTYStringIO())

 

225

            test_progress._TTYStringIO(),

 

226

            test_progress._TTYStringIO())

294

227

        self.assertIsInstance(ui_factory._progress_view,

295

228

            _mod_ui_text.TextProgressView)

296

229

        ui_factory.be_quiet(True)

355

288

    def test_progress_construction(self):

356

289

        """TextUIFactory constructs the right progress view.

357

290

        """

 

291

        TTYStringIO = test_progress._TTYStringIO

358

292

        FileStringIO = tests.StringIOWrapper

359

293

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

360

294

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

387

321

 

388

322

    def test_text_ui_non_terminal(self):

389

323

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

390

 

        stdin = NonTTYStringIO('')

391

 

        stderr = NonTTYStringIO()

392

 

        stdout = NonTTYStringIO()

 

324

        stdin = test_progress._NonTTYStringIO('')

 

325

        stderr = test_progress._NonTTYStringIO()

 

326

        stdout = test_progress._NonTTYStringIO()

393

327

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

394

328

            self.overrideEnv('TERM', term_type)

395

329

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

• Older »

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