git ssb

1
const tape = require('tape')
2
const IPFS = require('ipfs')
3
const Hypervisor = require('../')
4
const Message = require('primea-message')
5
6
const node = new IPFS()
7
8
class BaseContainer {
9
  constructor (kernel) {
10
    this.kernel = kernel
11
  }
12
13
  static createState (code) {
14
    return {
15
      nonce: [0],
16
      ports: {}
17
    }
18
  }
19
}
20
21
node.on('error', err => {
22
  console.log(err)
23
})
24
25
node.on('start', () => {
26
  tape('basic', async t => {
27
    const message = new Message()
28
    const expectedState = {
29
      '/': 'zdpuB3eZQJuXMnQrdiF5seMvx3zC2xT1EqrQScoPcTs8ESxYx'
30
    }
31
32
    class testVMContainer extends BaseContainer {
33
      run (m) {
34
        t.true(m === message, 'should recive a message')
35
      }
36
    }
37
38
    const hypervisor = new Hypervisor({dag: node.dag})
39
    hypervisor.addVM('test', testVMContainer)
40
    const port = hypervisor.createPort('test')
41
42
    await hypervisor.send(port, message)
43
    await hypervisor.createStateRoot(port, Infinity)
44
45
    t.deepEquals(port, expectedState, 'expected')
46
    t.end()
47
  })
48
49
  tape('one child contract', async t => {
50
    let message = new Message()
51
    const expectedState = { '/': 'zdpuAqtY43BMaTCB5nTt7kooeKAWibqGs44Uwy9jJQHjTnHRK' }
52
    let hasResolved = false
53
54
    class testVMContainer2 extends BaseContainer {
55
      run (m) {
56
        t.true(m === message, 'should recive a message 2')
57
        return new Promise((resolve, reject) => {
58
          setTimeout(() => {
59
            this.kernel.incrementTicks(1)
60
            hasResolved = true
61
            resolve()
62
          }, 200)
63
        })
64
      }
65
    }
66
67
    class testVMContainer extends BaseContainer {
68
      async run (m) {
69
        const port = await this.kernel.createPort(this.kernel.ports, 'test2', 'child')
70
        await this.kernel.send(port, m)
71
        this.kernel.incrementTicks(1)
72
      }
73
    }
74
75
    const hypervisor = new Hypervisor({dag: node.dag})
76
    hypervisor.addVM('test', testVMContainer)
77
    hypervisor.addVM('test2', testVMContainer2)
78
    const port = hypervisor.createPort('test')
79
80
    await hypervisor.send(port, message)
81
    await hypervisor.createStateRoot(port, Infinity)
82
    t.true(hasResolved, 'should resolve before generating the state root')
83
    t.deepEquals(port, expectedState, 'expected state')
84
85
    // test reviving the state
86
    class testVMContainer3 extends BaseContainer {
87
      async run (m) {
88
        const port = this.kernel.getPort(this.kernel.ports, 'child')
89
        this.kernel.send(port, m)
90
        this.kernel.incrementTicks(1)
91
      }
92
    }
93
94
    hypervisor.addVM('test', testVMContainer3)
95
96
    // revive ports
97
    message = new Message()
98
    await hypervisor.graph.tree(expectedState, 1)
99
    await hypervisor.send(expectedState['/'], message)
100
    await hypervisor.createStateRoot(expectedState['/'], Infinity)
101
102
    t.end()
103
  })
104
105
  tape('should wiat on parent', async t => {
106
    let r
107
    const lock = new Promise((resolve, reject) => {
108
      r = resolve
109
    })
110
111
    let parentHasFinished = false
112
    let childHasFinished = false
113
    class testVMContainer extends BaseContainer {
114
      async run (m) {
115
        console.log('in parent')
116
        const port = await this.kernel.createPort(this.kernel.ports, 'test2', 'child')
117
        await this.kernel.send(port, m)
118
        await lock
119
        return new Promise((resolve, reject) => {
120
          setTimeout(() => {
121
            console.log('parent done')
122
            this.kernel.incrementTicks(1)
123
            parentHasFinished = true
124
            t.equals(childHasFinished, false, 'child should not have finished at this point')
125
            resolve()
126
          }, 200)
127
        })
128
      }
129
    }
130
131
    // test reviving the state
132
    class testVMContainer2 extends BaseContainer {
133
      async run (m) {
134
        console.log('in child')
135
        childHasFinished = true
136
        r()
137
        this.kernel.incrementTicks(1)
138
        try {
139
          await this.kernel.ports.getNextMessage()
140
        } catch (e) {
141
          console.log(e)
142
        }
143
        t.equals(parentHasFinished, true, 'parent should have finished at this point')
144
      }
145
    }
146
147
    const hypervisor = new Hypervisor({dag: node.dag})
148
    hypervisor.addVM('test', testVMContainer)
149
    hypervisor.addVM('test2', testVMContainer2)
150
    const port = hypervisor.createPort('test')
151
152
    let message = new Message()
153
    try {
154
      await hypervisor.send(port, message)
155
      await hypervisor.createStateRoot(port, Infinity)
156
    } catch (e) {
157
      console.log(e)
158
    }
159
160
    t.end()
161
    node.stop(() => {
162
      process.exit()
163
    })
164
  })
165
})
166