~certify-web-dev/twisted/certify-trunk

« back to all changes in this revision

Viewing changes to twisted/conch/test/test_manhole.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-01-17 14:52:35 UTC
  • mfrom: (1.1.5 upstream) (2.1.2 etch)
  • Revision ID: james.westby@ubuntu.com-20070117145235-btmig6qfmqfen0om
Tags: 2.5.0-0ubuntu1
New upstream version, compatible with python2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# -*- test-case-name: twisted.conch.test.test_manhole -*-
 
2
# Copyright (c) 2001-2004 Twisted Matrix Laboratories.
 
3
# See LICENSE for details.
 
4
 
 
5
from __future__ import generators
 
6
 
 
7
import traceback
 
8
 
 
9
from twisted.trial import unittest
 
10
from twisted.internet import error, defer
 
11
from twisted.conch.test.test_recvline import _TelnetMixin, _SSHMixin, _StdioMixin, stdio, ssh
 
12
from twisted.conch import manhole
 
13
 
 
14
def determineDefaultFunctionName():
 
15
    """
 
16
    Return the string used by Python as the name for code objects which are
 
17
    compiled from interactive input or at the top-level of modules.
 
18
    """
 
19
    try:
 
20
        1 / 0
 
21
    except:
 
22
        return traceback.extract_stack()[0][2]
 
23
defaultFunctionName = determineDefaultFunctionName()
 
24
 
 
25
 
 
26
class WriterTestCase(unittest.TestCase):
 
27
    def testInteger(self):
 
28
        manhole.lastColorizedLine("1")
 
29
 
 
30
 
 
31
    def testDoubleQuoteString(self):
 
32
        manhole.lastColorizedLine('"1"')
 
33
 
 
34
 
 
35
    def testSingleQuoteString(self):
 
36
        manhole.lastColorizedLine("'1'")
 
37
 
 
38
 
 
39
    def testTripleSingleQuotedString(self):
 
40
        manhole.lastColorizedLine("'''1'''")
 
41
 
 
42
 
 
43
    def testTripleDoubleQuotedString(self):
 
44
        manhole.lastColorizedLine('"""1"""')
 
45
 
 
46
 
 
47
    def testFunctionDefinition(self):
 
48
        manhole.lastColorizedLine("def foo():")
 
49
 
 
50
 
 
51
    def testClassDefinition(self):
 
52
        manhole.lastColorizedLine("class foo:")
 
53
 
 
54
 
 
55
class ManholeLoopbackMixin:
 
56
    serverProtocol = manhole.ColoredManhole
 
57
 
 
58
    def wfd(self, d):
 
59
        return defer.waitForDeferred(d)
 
60
 
 
61
    def testSimpleExpression(self):
 
62
        done = self.recvlineClient.expect("done")
 
63
 
 
64
        self._testwrite(
 
65
            "1 + 1\n"
 
66
            "done")
 
67
 
 
68
        def finished(ign):
 
69
            self._assertBuffer(
 
70
                [">>> 1 + 1",
 
71
                 "2",
 
72
                 ">>> done"])
 
73
 
 
74
        return done.addCallback(finished)
 
75
 
 
76
    def testTripleQuoteLineContinuation(self):
 
77
        done = self.recvlineClient.expect("done")
 
78
 
 
79
        self._testwrite(
 
80
            "'''\n'''\n"
 
81
            "done")
 
82
 
 
83
        def finished(ign):
 
84
            self._assertBuffer(
 
85
                [">>> '''",
 
86
                 "... '''",
 
87
                 "'\\n'",
 
88
                 ">>> done"])
 
89
 
 
90
        return done.addCallback(finished)
 
91
 
 
92
    def testFunctionDefinition(self):
 
93
        done = self.recvlineClient.expect("done")
 
94
 
 
95
        self._testwrite(
 
96
            "def foo(bar):\n"
 
97
            "\tprint bar\n\n"
 
98
            "foo(42)\n"
 
99
            "done")
 
100
 
 
101
        def finished(ign):
 
102
            self._assertBuffer(
 
103
                [">>> def foo(bar):",
 
104
                 "...     print bar",
 
105
                 "... ",
 
106
                 ">>> foo(42)",
 
107
                 "42",
 
108
                 ">>> done"])
 
109
 
 
110
        return done.addCallback(finished)
 
111
 
 
112
    def testClassDefinition(self):
 
113
        done = self.recvlineClient.expect("done")
 
114
 
 
115
        self._testwrite(
 
116
            "class Foo:\n"
 
117
            "\tdef bar(self):\n"
 
118
            "\t\tprint 'Hello, world!'\n\n"
 
119
            "Foo().bar()\n"
 
120
            "done")
 
121
 
 
122
        def finished(ign):
 
123
            self._assertBuffer(
 
124
                [">>> class Foo:",
 
125
                 "...     def bar(self):",
 
126
                 "...         print 'Hello, world!'",
 
127
                 "... ",
 
128
                 ">>> Foo().bar()",
 
129
                 "Hello, world!",
 
130
                 ">>> done"])
 
131
 
 
132
        return done.addCallback(finished)
 
133
 
 
134
    def testException(self):
 
135
        done = self.recvlineClient.expect("done")
 
136
 
 
137
        self._testwrite(
 
138
            "1 / 0\n"
 
139
            "done")
 
140
 
 
141
        def finished(ign):
 
142
            self._assertBuffer(
 
143
                [">>> 1 / 0",
 
144
                 "Traceback (most recent call last):",
 
145
                 '  File "<console>", line 1, in ' + defaultFunctionName,
 
146
                 "ZeroDivisionError: integer division or modulo by zero",
 
147
                 ">>> done"])
 
148
 
 
149
        return done.addCallback(finished)
 
150
 
 
151
    def testControlC(self):
 
152
        done = self.recvlineClient.expect("done")
 
153
 
 
154
        self._testwrite(
 
155
            "cancelled line" + manhole.CTRL_C +
 
156
            "done")
 
157
 
 
158
        def finished(ign):
 
159
            self._assertBuffer(
 
160
                [">>> cancelled line",
 
161
                 "KeyboardInterrupt",
 
162
                 ">>> done"])
 
163
 
 
164
        return done.addCallback(finished)
 
165
 
 
166
    def testControlBackslash(self):
 
167
        self._testwrite("cancelled line")
 
168
        partialLine = self.recvlineClient.expect("cancelled line")
 
169
 
 
170
        def gotPartialLine(ign):
 
171
            self._assertBuffer(
 
172
                [">>> cancelled line"])
 
173
            self._testwrite(manhole.CTRL_BACKSLASH)
 
174
 
 
175
            d = self.recvlineClient.onDisconnection
 
176
            return self.assertFailure(d, error.ConnectionDone)
 
177
 
 
178
        def gotClearedLine(ign):
 
179
            self._assertBuffer(
 
180
                [""])
 
181
 
 
182
        return partialLine.addCallback(gotPartialLine).addCallback(gotClearedLine)
 
183
 
 
184
    def testControlD(self):
 
185
        self._testwrite("1 + 1")
 
186
        helloWorld = self.wfd(self.recvlineClient.expect(r"\+ 1"))
 
187
        yield helloWorld
 
188
        helloWorld.getResult()
 
189
        self._assertBuffer([">>> 1 + 1"])
 
190
 
 
191
        self._testwrite(manhole.CTRL_D + " + 1")
 
192
        cleared = self.wfd(self.recvlineClient.expect(r"\+ 1"))
 
193
        yield cleared
 
194
        cleared.getResult()
 
195
        self._assertBuffer([">>> 1 + 1 + 1"])
 
196
 
 
197
        self._testwrite("\n")
 
198
        printed = self.wfd(self.recvlineClient.expect("3\n>>> "))
 
199
        yield printed
 
200
        printed.getResult()
 
201
 
 
202
        self._testwrite(manhole.CTRL_D)
 
203
        d = self.recvlineClient.onDisconnection
 
204
        disconnected = self.wfd(self.assertFailure(d, error.ConnectionDone))
 
205
        yield disconnected
 
206
        disconnected.getResult()
 
207
    testControlD = defer.deferredGenerator(testControlD)
 
208
 
 
209
 
 
210
    def testControlL(self):
 
211
        """
 
212
        CTRL+L is generally used as a redraw-screen command in terminal
 
213
        applications.  Manhole doesn't currently respect this usage of it,
 
214
        but it should at least do something reasonable in response to this
 
215
        event (rather than, say, eating your face).
 
216
        """
 
217
        # Start off with a newline so that when we clear the display we can
 
218
        # tell by looking for the missing first empty prompt line.
 
219
        self._testwrite("\n1 + 1")
 
220
        helloWorld = self.wfd(self.recvlineClient.expect(r"\+ 1"))
 
221
        yield helloWorld
 
222
        helloWorld.getResult()
 
223
        self._assertBuffer([">>> ", ">>> 1 + 1"])
 
224
 
 
225
        self._testwrite(manhole.CTRL_L + " + 1")
 
226
        redrew = self.wfd(self.recvlineClient.expect(r"1 \+ 1 \+ 1"))
 
227
        yield redrew
 
228
        redrew.getResult()
 
229
        self._assertBuffer([">>> 1 + 1 + 1"])
 
230
    testControlL = defer.deferredGenerator(testControlL)
 
231
 
 
232
 
 
233
    def testDeferred(self):
 
234
        self._testwrite(
 
235
            "from twisted.internet import defer, reactor\n"
 
236
            "d = defer.Deferred()\n"
 
237
            "d\n")
 
238
 
 
239
        deferred = self.wfd(self.recvlineClient.expect("<Deferred #0>"))
 
240
        yield deferred
 
241
        deferred.getResult()
 
242
 
 
243
        self._testwrite(
 
244
            "c = reactor.callLater(0.1, d.callback, 'Hi!')\n")
 
245
        delayed = self.wfd(self.recvlineClient.expect(">>> "))
 
246
        yield delayed
 
247
        delayed.getResult()
 
248
 
 
249
        called = self.wfd(self.recvlineClient.expect("Deferred #0 called back: 'Hi!'\n>>> "))
 
250
        yield called
 
251
        called.getResult()
 
252
        self._assertBuffer(
 
253
            [">>> from twisted.internet import defer, reactor",
 
254
             ">>> d = defer.Deferred()",
 
255
             ">>> d",
 
256
             "<Deferred #0>",
 
257
             ">>> c = reactor.callLater(0.1, d.callback, 'Hi!')",
 
258
             "Deferred #0 called back: 'Hi!'",
 
259
             ">>> "])
 
260
 
 
261
    testDeferred = defer.deferredGenerator(testDeferred)
 
262
 
 
263
class ManholeLoopbackTelnet(_TelnetMixin, unittest.TestCase, ManholeLoopbackMixin):
 
264
    pass
 
265
 
 
266
class ManholeLoopbackSSH(_SSHMixin, unittest.TestCase, ManholeLoopbackMixin):
 
267
    if ssh is None:
 
268
        skip = "Crypto requirements missing, can't run manhole tests over ssh"
 
269
 
 
270
class ManholeLoopbackStdio(_StdioMixin, unittest.TestCase, ManholeLoopbackMixin):
 
271
    if stdio is None:
 
272
        skip = "Terminal requirements missing, can't run manhole tests over stdio"
 
273
    else:
 
274
        serverProtocol = stdio.ConsoleManhole