wip: update runtime-test

packages/runtime-core/src/component.ts

@@ -254,6 +254,11 @@ export function setupStatefulComponent(instance: ComponentInstance) {
       }
       instance.render = Component.render as RenderFunction
     }
+  } else {
+    if (__DEV__ && !Component.render) {
+      // TODO warn missing render fn
+    }
+    instance.render = Component.render as RenderFunction
   }
 }
 

packages/runtime-test/__tests__/testRuntime.spec.ts

@@ -4,18 +4,19 @@ import {
   nodeOps,
   NodeTypes,
   TestElement,
-  TestText
+  TestText,
-  // dumpOps,
+  ref,
-  // NodeOpTypes,
+  reactive,
-  // nextTick,
+  dumpOps,
-  // state,
+  resetOps,
-  // resetOps,
+  NodeOpTypes,
-  // serialize,
+  nextTick,
-  // triggerEvent
+  serialize,
+  triggerEvent
 } from '../src'
 
 describe('test renderer', () => {
-  it('should work', async () => {
+  it('should work', () => {
     const root = nodeOps.createElement('div')
     render(
       h(
@@ -40,137 +41,132 @@ describe('test renderer', () => {
     expect(text.text).toBe('hello')
   })
 
-  //   it('should record ops', async () => {
+  it('should record ops', async () => {
-  //     const store = state({
+    const state = reactive({
-  //       id: 'test',
+      id: 'test',
-  //       text: 'hello'
+      text: 'hello'
-  //     })
+    })
 
-  //     class App extends Component {
+    const App = {
-  //       render() {
+      render() {
-  //         return h(
+        return h(
-  //           'div',
+          'div',
-  //           {
+          {
-  //             id: store.id
+            id: state.id
-  //           },
+          },
-  //           store.text
+          state.text
-  //         )
+        )
-  //       }
+      }
-  //     }
+    }
-  //     const root = nodeOps.createElement('div')
+    const root = nodeOps.createElement('div')
 
-  //     resetOps()
+    resetOps()
-  //     await render(h(App), root)
+    render(h(App), root)
-  //     const ops = dumpOps()
+    const ops = dumpOps()
 
-  //     expect(ops.length).toBe(5)
+    expect(ops.length).toBe(4)
 
-  //     expect(ops[0]).toEqual({
+    expect(ops[0]).toEqual({
-  //       type: NodeOpTypes.CREATE,
+      type: NodeOpTypes.CREATE,
-  //       nodeType: NodeTypes.ELEMENT,
+      nodeType: NodeTypes.ELEMENT,
-  //       tag: 'div',
+      tag: 'div',
-  //       targetNode: root.children[0]
+      targetNode: root.children[0]
-  //     })
+    })
 
-  //     expect(ops[1]).toEqual({
+    expect(ops[1]).toEqual({
-  //       type: NodeOpTypes.PATCH,
+      type: NodeOpTypes.PATCH,
-  //       targetNode: root.children[0],
+      targetNode: root.children[0],
-  //       propKey: 'id',
+      propKey: 'id',
-  //       propPrevValue: null,
+      propPrevValue: null,
-  //       propNextValue: 'test'
+      propNextValue: 'test'
-  //     })
+    })
 
-  //     expect(ops[2]).toEqual({
+    expect(ops[2]).toEqual({
-  //       type: NodeOpTypes.CREATE,
+      type: NodeOpTypes.SET_ELEMENT_TEXT,
-  //       nodeType: NodeTypes.TEXT,
+      text: 'hello',
-  //       text: 'hello',
+      targetNode: root.children[0]
-  //       targetNode: (root.children[0] as TestElement).children[0]
+    })
-  //     })
 
-  //     expect(ops[3]).toEqual({
+    expect(ops[3]).toEqual({
-  //       type: NodeOpTypes.APPEND,
+      type: NodeOpTypes.INSERT,
-  //       targetNode: (root.children[0] as TestElement).children[0],
+      targetNode: root.children[0],
-  //       parentNode: root.children[0]
+      parentNode: root,
-  //     })
+      refNode: null
+    })
 
-  //     expect(ops[4]).toEqual({
+    // test update ops
-  //       type: NodeOpTypes.APPEND,
+    state.id = 'foo'
-  //       targetNode: root.children[0],
+    state.text = 'bar'
-  //       parentNode: root
+    await nextTick()
-  //     })
 
-  //     // test update ops
+    const updateOps = dumpOps()
-  //     store.id = 'foo'
+    expect(updateOps.length).toBe(2)
-  //     store.text = 'bar'
-  //     await nextTick()
 
-  //     const updateOps = dumpOps()
+    expect(updateOps[0]).toEqual({
-  //     expect(updateOps.length).toBe(2)
+      type: NodeOpTypes.PATCH,
+      targetNode: root.children[0],
+      propKey: 'id',
+      propPrevValue: 'test',
+      propNextValue: 'foo'
+    })
 
-  //     expect(updateOps[0]).toEqual({
+    expect(updateOps[1]).toEqual({
-  //       type: NodeOpTypes.PATCH,
+      type: NodeOpTypes.SET_ELEMENT_TEXT,
-  //       targetNode: root.children[0],
+      targetNode: root.children[0],
-  //       propKey: 'id',
+      text: 'bar'
-  //       propPrevValue: 'test',
+    })
-  //       propNextValue: 'foo'
+  })
-  //     })
 
-  //     expect(updateOps[1]).toEqual({
+  it('should be able to serialize nodes', () => {
-  //       type: NodeOpTypes.SET_TEXT,
+    const App = {
-  //       targetNode: (root.children[0] as TestElement).children[0],
+      render() {
-  //       text: 'bar'
+        return h(
-  //     })
+          'div',
-  //   })
+          {
+            id: 'test'
+          },
+          [h('span', 0, 'foo'), 'hello']
+        )
+      }
+    }
+    const root = nodeOps.createElement('div')
+    render(h(App), root)
+    expect(serialize(root)).toEqual(
+      `<div><div id="test"><span>foo</span>hello</div></div>`
+    )
+    // indented output
+    expect(serialize(root, 2)).toEqual(
+      `<div>
+  <div id="test">
+    <span>
+      foo
+    </span>
+    hello
+  </div>
+</div>`
+    )
+  })
 
-  //   it('should be able to serialize nodes', async () => {
+  it('should be able to trigger events', async () => {
-  //     class App extends Component {
+    const count = ref(0)
-  //       render() {
-  //         return h(
-  //           'div',
-  //           {
-  //             id: 'test'
-  //           },
-  //           [h('span', 'foo'), 'hello']
-  //         )
-  //       }
-  //     }
-  //     const root = nodeOps.createElement('div')
-  //     await render(h(App), root)
-  //     expect(serialize(root)).toEqual(
-  //       `<div><div id="test"><span>foo</span>hello</div></div>`
-  //     )
-  //     expect(serialize(root, 2)).toEqual(
-  //       `<div>
-  //   <div id="test">
-  //     <span>
-  //       foo
-  //     </span>
-  //     hello
-  //   </div>
-  // </div>`
-  //     )
-  //   })
 
-  //   it('should be able to trigger events', async () => {
+    const App = () => {
-  //     class App extends Component {
+      return h(
-  //       count = 0
+        'span',
-  //       inc() {
+        {
-  //         this.count++
+          onClick: () => {
-  //       }
+            count.value++
-  //       render() {
+          }
-  //         return h(
+        },
-  //           'div',
+        count.value
-  //           {
+      )
-  //             onClick: this.inc
+    }
-  //           },
+
-  //           this.count
+    const root = nodeOps.createElement('div')
-  //         )
+    render(h(App), root)
-  //       }
+    triggerEvent(root.children[0] as TestElement, 'click')
-  //     }
+    expect(count.value).toBe(1)
-  //     const app = await renderInstance(App)
+    await nextTick()
-  //     triggerEvent(app.$el, 'click')
+    expect(serialize(root)).toBe(`<div><span>1</span></div>`)
-  //     expect(app.count).toBe(1)
+  })
-  //     await nextTick()
-  //     expect(serialize(app.$el)).toBe(`<div>1</div>`)
-  //   })
 })

packages/runtime-test/src/nodeOps.ts

@@ -4,6 +4,15 @@ export const enum NodeTypes {
   COMMENT = 'comment'
 }
 
+export const enum NodeOpTypes {
+  CREATE = 'create',
+  INSERT = 'insert',
+  REMOVE = 'remove',
+  SET_TEXT = 'setText',
+  SET_ELEMENT_TEXT = 'setElementText',
+  PATCH = 'patch'
+}
+
 export interface TestElement {
   id: number
   type: NodeTypes.ELEMENT
@@ -30,15 +39,6 @@ export interface TestComment {
 
 export type TestNode = TestElement | TestText | TestComment
 
-export const enum NodeOpTypes {
-  CREATE = 'create',
-  INSERT = 'insert',
-  REMOVE = 'remove',
-  SET_TEXT = 'setText',
-  SET_ELEMENT_TEXT = 'setElementText',
-  PATCH = 'patch'
-}
-
 export interface NodeOp {
   type: NodeOpTypes
   nodeType?: NodeTypes
@@ -184,7 +184,14 @@ function setElementText(el: TestElement, text: string) {
   el.children.forEach(c => {
     c.parentNode = null
   })
-  el.children = [createText(text)]
+  el.children = [
+    {
+      id: nodeId++,
+      type: NodeTypes.TEXT,
+      text,
+      parentNode: el
+    }
+  ]
 }
 
 function parentNode(node: TestNode): TestElement | null {