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
      '/': 'zdpuAntkdU7yBJojcBT5Q9wBhrK56NmLnwpHPKaEGMFnAXpv7'
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.registerContainer('test', testVMContainer)
40
41
    const rootContainer = await hypervisor.createInstance('test')
42
    const port = await rootContainer.createPort('test', 'first')
43
44
    await rootContainer.send(port, message)
45
46
    const stateRoot = await hypervisor.createStateRoot(rootContainer, Infinity)
47
    t.deepEquals(stateRoot, expectedState, 'expected root!')
48
    t.end()
49
  })
50
51
  tape.only('one child contract', async t => {
52
    let message = new Message()
53
    const expectedState = { '/': 'zdpuAqtY43BMaTCB5nTt7kooeKAWibqGs44Uwy9jJQHjTnHRK' }
54
    let hasResolved = false
55
56
    class testVMContainer2 extends BaseContainer {
57
      run (m) {
58
        t.true(m === message, 'should recive a message 2')
59
        return new Promise((resolve, reject) => {
60
          setTimeout(() => {
61
            this.kernel.incrementTicks(1)
62
            hasResolved = true
63
            resolve()
64
          }, 200)
65
        })
66
      }
67
    }
68
69
    class testVMContainer extends BaseContainer {
70
      async run (m) {
71
        const port = await this.kernel.createPort('test2', 'child')
72
        await this.kernel.send(port, m)
73
        this.kernel.incrementTicks(1)
74
      }
75
    }
76
77
    try {
78
      const hypervisor = new Hypervisor({dag: node.dag})
79
      hypervisor.registerContainer('test', testVMContainer)
80
      hypervisor.registerContainer('test2', testVMContainer2)
81
82
      const root = await hypervisor.createInstance('test')
83
      const port = await root.createPort('test', 'first')
84
85
      await root.send(port, message)
86
      await hypervisor.createStateRoot(root, Infinity)
87
      console.log('state root generated')
88
      t.true(hasResolved, 'should resolve before generating the state root')
89
    } catch (e) {
90
      console.log(e)
91
    }
92
    // t.deepEquals(port, expectedState, 'expected state')
93
94
    // test reviving the state
95
    // class testVMContainer3 extends BaseContainer {
96
    //   async run (m) {
97
    //     const port = this.kernel.getPort(this.kernel.ports, 'child')
98
    //     this.kernel.send(port, m)
99
    //     this.kernel.incrementTicks(1)
100
    //   }
101
    // }
102
103
    // hypervisor.addVM('test', testVMContainer3)
104
105
    // // revive ports
106
    // message = new Message()
107
    // await hypervisor.graph.tree(expectedState, 1)
108
    // await hypervisor.send(expectedState['/'], message)
109
    // await hypervisor.createStateRoot(expectedState['/'], Infinity)
110
111
    t.end()
112
  })
113
114
  tape('should wait on parent', async t => {
115
    let r
116
    const lock = new Promise((resolve, reject) => {
117
      r = resolve
118
    })
119
120
    let parentHasFinished = false
121
    let childHasFinished = false
122
    class testVMContainer extends BaseContainer {
123
      async run (m) {
124
        console.log('in parent')
125
        const port = await this.kernel.createPort(this.kernel.ports, 'test2', 'child')
126
        await this.kernel.send(port, m)
127
        await lock
128
        return new Promise((resolve, reject) => {
129
          setTimeout(() => {
130
            console.log('parent done')
131
            this.kernel.incrementTicks(1)
132
            parentHasFinished = true
133
            t.equals(childHasFinished, false, 'child should not have finished at this point')
134
            resolve()
135
          }, 200)
136
        })
137
      }
138
    }
139
140
    // test reviving the state
141
    class testVMContainer2 extends BaseContainer {
142
      async run (m) {
143
        console.log('in child')
144
        childHasFinished = true
145
        r()
146
        this.kernel.incrementTicks(1)
147
        try {
148
          await this.kernel.ports.getNextMessage()
149
        } catch (e) {
150
          console.log(e)
151
        }
152
        t.equals(parentHasFinished, true, 'parent should have finished at this point')
153
      }
154
    }
155
156
    const hypervisor = new Hypervisor({dag: node.dag})
157
    hypervisor.addVM('test', testVMContainer)
158
    hypervisor.addVM('test2', testVMContainer2)
159
    const port = hypervisor.createPort('test')
160
161
    let message = new Message()
162
    try {
163
      await hypervisor.send(port, message)
164
      await hypervisor.createStateRoot(port, Infinity)
165
    } catch (e) {
166
      console.log(e)
167
    }
168
169
    t.end()
170
    node.stop(() => {
171
      process.exit()
172
    })
173
  })
174
})
175