git ssb

1
const tape = require('tape')
2
const fs = require('fs')
3
const Hypervisor = require('primea-hypervisor')
4
const Message = require('primea-message')
5
const WasmContainer = require('../index.js')
6
const testInterface = require('./testInterface.js')
7
const IPFS = require('ipfs')
8
9
const node = new IPFS({
10
  start: false
11
})
12
13
class ContainerTestInterface {
14
  constructor (wasmContainer) {
15
    this.wasmContainer = wasmContainer
16
  }
17
18
  readMem (offset) {
19
    return this.wasmContainer.getMemory(offset, 1)
20
  }
21
22
  async callback (cb) {
23
    const promise = new Promise((resolve, reject) => {
24
      resolve()
25
    })
26
    await this.wasmContainer.pushOpsQueue(promise)
27
    this.wasmContainer.execute(cb)
28
  }
29
}
30
31
node.on('ready', () => {
32
  tape('wasm container - main', async t => {
33
    t.plan(1)
34
    const hypervisor = new Hypervisor(node.dag)
35
    const main = fs.readFileSync(`${__dirname}/wasm/run.wasm`)
36
    hypervisor.registerContainer(WasmContainer, {
37
      test: testInterface(t)
38
    })
39
    const instance = await hypervisor.createInstance(WasmContainer.typeId, new Message({
40
      data: main
41
    }))
42
    instance.message(instance.createMessage())
43
  })
44
45
  tape('wasm container - mem', async t => {
46
    t.plan(1)
47
    try {
48
      const hypervisor = new Hypervisor(node.dag)
49
      const readMem = fs.readFileSync(`${__dirname}/wasm/readMem.wasm`)
50
      hypervisor.registerContainer(WasmContainer, {
51
        env: ContainerTestInterface,
52
        test: testInterface(t)
53
      })
54
      await hypervisor.createInstance(WasmContainer.typeId, new Message({
55
        data: readMem
56
      }))
57
    } catch (e) {
58
      console.log(e)
59
    }
60
  })
61
62
  tape('wasm container - callbacks', async t => {
63
    t.plan(1)
64
    const hypervisor = new Hypervisor(node.dag)
65
    const callBackWasm = fs.readFileSync(`${__dirname}/wasm/callback.wasm`)
66
    hypervisor.registerContainer(WasmContainer, {
67
      env: ContainerTestInterface,
68
      test: testInterface(t)
69
    })
70
    hypervisor.createInstance(WasmContainer.typeId, new Message({
71
      data: callBackWasm
72
    }))
73
  })
74
75
  tape('wasm container - invalid', async t => {
76
    t.plan(1)
77
    const hypervisor = new Hypervisor(node.dag)
78
    hypervisor.registerContainer(WasmContainer, {
79
      env: ContainerTestInterface,
80
      test: testInterface(t)
81
    })
82
83
    const message = new Message({
84
      data: Buffer.from([0x00])
85
    })
86
87
    const rp = message.responsePort = {destPort: {messages: []}}
88
89
    await hypervisor.createInstance(WasmContainer.typeId, message)
90
    t.equals(rp.destPort.messages[0].data.exception, true)
91
  })
92
93
  tape('initailize', async t => {
94
    t.plan(2)
95
96
    const callBackWasm = fs.readFileSync(`${__dirname}/wasm/callback.wasm`)
97
98
    class ContainerTestInterface {
99
      constructor (wasmContainer) {
100
        this.wasmContainer = wasmContainer
101
      }
102
103
      readMem (offset) {
104
        return this.wasmContainer.getMemory(offset, 1)
105
      }
106
107
      async callback (cb) {
108
        const promise = new Promise((resolve, reject) => {
109
          resolve()
110
        })
111
        await this.wasmContainer.pushOpsQueue(promise)
112
        this.wasmContainer.execute(cb)
113
      }
114
115
      static initialize (code) {
116
        t.equals(code, callBackWasm)
117
        return code
118
      }
119
    }
120
121
    const hypervisor = new Hypervisor(node.dag)
122
    hypervisor.registerContainer(WasmContainer, {
123
      env: ContainerTestInterface,
124
      test: testInterface(t)
125
    })
126
127
    const message = new Message({
128
      data: callBackWasm
129
    })
130
131
    hypervisor.createInstance(WasmContainer.typeId, message)
132
  })
133
})
134