code-interpreter/js/tests/contexts.test.ts at abe6a0280ba4b8cb485078fcc70ffca99ffb8792 · e2b-dev/code-interpreter · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
import { expect } from 'vitest'

import { isDebug, sandboxTest } from './setup'
import Sandbox from '../src'

sandboxTest('create context with no options', async ({ sandbox }) => {
  const context = await sandbox.createCodeContext()

  const contexts = await sandbox.listCodeContexts()
  const lastContext = contexts[contexts.length - 1]

  expect(lastContext.id).toBe(context.id)
  expect(lastContext.language).toBe(context.language)
  expect(lastContext.cwd).toBe(context.cwd)
})

sandboxTest('create context with options', async ({ sandbox }) => {
  const context = await sandbox.createCodeContext({
    language: 'python',
    cwd: '/root',
  })

  const contexts = await sandbox.listCodeContexts()
  const lastContext = contexts[contexts.length - 1]

  expect(lastContext.id).toBe(context.id)
  expect(lastContext.language).toBe(context.language)
  expect(lastContext.cwd).toBe(context.cwd)
})

sandboxTest('remove context', async ({ sandbox }) => {
  const context = await sandbox.createCodeContext()

  await sandbox.removeCodeContext(context.id)
  const contexts = await sandbox.listCodeContexts()

  expect(contexts.map((context) => context.id)).not.toContain(context.id)
})

sandboxTest('list contexts', async ({ sandbox }) => {
  const contexts = await sandbox.listCodeContexts()

  // default contexts should include python and javascript
  expect(contexts.map((context) => context.language)).toContain('python')
  expect(contexts.map((context) => context.language)).toContain('javascript')
})

sandboxTest('restart context', async ({ sandbox }) => {
  const context = await sandbox.createCodeContext()

  // set a variable in the context
  await sandbox.runCode('x = 1', { context: context })

  // restart the context
  await sandbox.restartCodeContext(context.id)

  // check that the variable no longer exists
  const execution = await sandbox.runCode('x', { context: context })

  // check for an NameError with message "name 'x' is not defined"
  expect(execution.error).toBeDefined()
  expect(execution.error?.name).toBe('NameError')
  expect(execution.error?.value).toBe("name 'x' is not defined")
})

sandboxTest.skipIf(isDebug)(
  'create context (secure traffic)',
  async ({ template }) => {
    const sandbox = await Sandbox.create(template, {
      network: {
        allowPublicTraffic: false,
      },
    })
    const context = await sandbox.createCodeContext()

    const contexts = await sandbox.listCodeContexts()
    const lastContext = contexts[contexts.length - 1]

    expect(lastContext.id).toBe(context.id)
    expect(lastContext.language).toBe(context.language)
    expect(lastContext.cwd).toBe(context.cwd)

    await sandbox.kill()
  }
)

sandboxTest.skipIf(isDebug)(
  'remove context (secure traffic)',
  async ({ template }) => {
    const sandbox = await Sandbox.create(template, {
      network: {
        allowPublicTraffic: false,
      },
    })
    const context = await sandbox.createCodeContext()

    await sandbox.removeCodeContext(context.id)
    const contexts = await sandbox.listCodeContexts()

    expect(contexts.map((context) => context.id)).not.toContain(context.id)

    await sandbox.kill()
  }
)

sandboxTest.skipIf(isDebug)(
  'list contexts (secure traffic)',
  async ({ template }) => {
    const sandbox = await Sandbox.create(template, {
      network: {
        allowPublicTraffic: false,
      },
    })
    const contexts = await sandbox.listCodeContexts()

    // default contexts should include python and javascript
    expect(contexts.map((context) => context.language)).toContain('python')
    expect(contexts.map((context) => context.language)).toContain('javascript')

    await sandbox.kill()
  }
)

sandboxTest.skipIf(isDebug)(
  'restart context (secure traffic)',
  async ({ template }) => {
    const sandbox = await Sandbox.create(template, {
      network: {
        allowPublicTraffic: false,
      },
    })
    const context = await sandbox.createCodeContext()

    // set a variable in the context
    await sandbox.runCode('x = 1', { context: context })

    // restart the context
    await sandbox.restartCodeContext(context.id)

    // check that the variable no longer exists
    const execution = await sandbox.runCode('x', { context: context })

    // check for an NameError with message "name 'x' is not defined"
    expect(execution.error).toBeDefined()
    expect(execution.error?.name).toBe('NameError')
    expect(execution.error?.value).toBe("name 'x' is not defined")

    await sandbox.kill()
  }
)