Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Avatar for KuCalc : devops.
 Download
50660 views
Tweet
Share
Share
1
###

2
Test backend part of interactive input.

3
###

4


5
expect  = require('expect')

6


7
common = require('./common')

8


9
describe 'get input using the python2 kernel -- ', ->

10
    @timeout(10000)

11
    kernel = undefined

12


13
    it 'creates a python2 kernel', ->

14
        kernel = common.kernel('python2')

15


16
    it 'reading input - no prompt', (done) ->

17
        kernel.execute_code

18
            code  : 'print(input())'

19
            all   : true

20
            stdin : (opts, cb) ->

21
                expect(opts).toEqual({ password: false, prompt: '' })

22
                cb(undefined, "'cocalc'")

23
            cb    : (err, v) ->

24
                if err

25
                    done(err)

26
                else

27
                    expect(common.output(v)).toEqual('cocalc\n')

28
                    done()

29


30
    it 'reading raw_input - no prompt', (done) ->

31
        kernel.execute_code

32
            code  : 'print(raw_input())'

33
            all   : true

34
            stdin : (opts, cb) ->

35
                expect(opts).toEqual({ password: false, prompt: '' })

36
                cb(undefined, "cocalc")

37
            cb    : (err, v) ->

38
                if err

39
                    done(err)

40
                else

41
                    expect(common.output(v)).toEqual('cocalc\n')

42
                    done()

43


44
    it 'reading input - prompt', (done) ->

45
        kernel.execute_code

46
            code  : 'print(input("prompt"))'

47
            all   : true

48
            stdin : (opts, cb) ->

49
                expect(opts).toEqual({ password: false, prompt: 'prompt' })

50
                cb(undefined, "'cocalc'")

51
            cb    : (err, v) ->

52
                if err

53
                    done(err)

54
                else

55
                    expect(common.output(v)).toEqual('cocalc\n')

56
                    done()

57


58
    it 'reading raw_input - prompt', (done) ->

59
        kernel.execute_code

60
            code  : 'print(raw_input("prompt"))'

61
            all   : true

62
            stdin : (opts, cb) ->

63
                expect(opts).toEqual({ password: false, prompt: 'prompt' })

64
                cb(undefined, "cocalc")

65
            cb    : (err, v) ->

66
                if err

67
                    done(err)

68
                else

69
                    expect(common.output(v)).toEqual('cocalc\n')

70
                    done()

71


72
    it 'reading a password', (done) ->

73
        kernel.execute_code

74
            code  : 'import getpass; print(getpass.getpass("password?"))'

75
            all   : true

76
            stdin : (opts, cb) ->

77
                expect(opts).toEqual({ password: true, prompt: 'password?' })

78
                cb(undefined, "cocalc")

79
            cb    : (err, v) ->

80
                if err

81
                    done(err)

82
                else

83
                    expect(common.output(v)).toEqual('cocalc\n')

84
                    done()

85


86
    it 'closes the kernel', ->

87
        kernel.close()

88
        expect(kernel._state).toBe('closed')

89
        expect(kernel._kernel).toBe(undefined)

90
        expect(kernel._channels).toBe(undefined)

91


92
describe 'get input using the python3 kernel -- ', ->

93
    @timeout(10000)

94


95
    it 'do it', (done) ->

96
        kernel = common.kernel('python3')

97
        kernel.execute_code

98
            code  : 'print(input("prompt"))'

99
            all   : true

100
            stdin : (opts, cb) ->

101
                expect(opts).toEqual({ password: false, prompt: 'prompt' })

102
                cb(undefined, "cocalc")

103
            cb    : (err, v) ->

104
                kernel.close()

105
                if err

106
                    done(err)

107
                else

108
                    expect(common.output(v)).toEqual('cocalc\n')

109
                    done()

110


111
describe 'get input using the ir kernel -- ', ->

112
    @timeout(15000)

113


114
    it 'do it', (done) ->

115
        kernel = common.kernel('ir')

116
        kernel.execute_code

117
            code  : 'print(readline("prompt"))'

118
            all   : true

119
            stdin : (opts, cb) ->

120
                expect(opts).toEqual({ password: false, prompt: 'prompt' })

121
                cb(undefined, "cocalc")

122
            cb    : (err, v) ->

123
                kernel.close()

124
                if err

125
                    done(err)

126
                else

127
                    expect(common.output(v)).toEqual('[1] "cocalc"\n')

128
                    done()

129


130