test: improve coverage

2019-09-24 16:35:01 -04:00
parent e67084e5a1
commit cae03f616d
8 changed files with 318 additions and 52 deletions
--- a/packages/compiler-core/tests/snapshots/codegen.spec.ts.snap
+++ b/packages/compiler-core/tests/snapshots/codegen.spec.ts.snap
@@ -5,8 +5,9 @@ exports[`compiler: codegen callExpression + objectExpression + arrayExpression 1
  with (this) {
    return createVNode(\\"div\\", {
      id: \\"foo\\",
-      [prop]: bar
-    }, [
+      [prop]: bar,
+      [foo + bar]: bar
+    }, [createVNode(\\"p\\", { \\"some-key\\": \\"foo\\" })], [
      foo,
      createVNode(\\"p\\")
    ])
@@ -22,6 +23,14 @@ exports[`compiler: codegen comment 1`] = `
 }"
 `;

+exports[`compiler: codegen compound expression 1`] = `
+"return function render() {
+  with (this) {
+    return toString(_ctx.foo)
+  }
+}"
+`;
+
 exports[`compiler: codegen forNode 1`] = `
 "return function render() {
  with (this) {
@@ -30,6 +39,30 @@ exports[`compiler: codegen forNode 1`] = `
 }"
 `;

+exports[`compiler: codegen forNode w/ skipped key alias 1`] = `
+"return function render() {
+  with (this) {
+    return renderList(list, (v, __key, i) => toString(v))
+  }
+}"
+`;
+
+exports[`compiler: codegen forNode w/ skipped value alias 1`] = `
+"return function render() {
+  with (this) {
+    return renderList(list, (__value, k, i) => toString(v))
+  }
+}"
+`;
+
+exports[`compiler: codegen forNode w/ skipped value and key aliases 1`] = `
+"return function render() {
+  with (this) {
+    return renderList(list, (__value, __key, i) => toString(v))
+  }
+}"
+`;
+
 exports[`compiler: codegen function mode preamble 1`] = `
 "const { helperOne, helperTwo } = Vue

@@ -52,6 +85,18 @@ exports[`compiler: codegen ifNode 1`] = `
 }"
 `;

+exports[`compiler: codegen ifNode with no v-else 1`] = `
+"return function render() {
+  with (this) {
+    return (foo)
+      ? \\"foo\\"
+      : (bar)
+        ? toString(bye)
+        : null
+  }
+}"
+`;
+
 exports[`compiler: codegen interpolation 1`] = `
 "return function render() {
  with (this) {
--- a/packages/compiler-core/tests/codegen.spec.ts
+++ b/packages/compiler-core/tests/codegen.spec.ts
@@ -7,9 +7,11 @@ import {
  createExpression,
  Namespaces,
  ElementTypes,
+  CallExpression,
  createObjectExpression,
  createObjectProperty,
-  createArrayExpression
+  createArrayExpression,
+  ElementNode
 } from '../src'
 import { SourceMapConsumer, RawSourceMap } from 'source-map'
 import { CREATE_VNODE, COMMENT, TO_STRING } from '../src/runtimeConstants'
@@ -145,6 +147,25 @@ describe('compiler: codegen', () => {
    expect(code).toMatchSnapshot()
  })

+  test('compound expression', () => {
+    const { code } = generate(
+      createRoot({
+        children: [
+          {
+            type: NodeTypes.EXPRESSION,
+            content: 'foo',
+            isStatic: false,
+            isInterpolation: true,
+            loc: mockLoc,
+            children: [`_ctx.`, createExpression(`foo`, false, mockLoc)]
+          }
+        ]
+      })
+    )
+    expect(code).toMatch(`return toString(_ctx.foo)`)
+    expect(code).toMatchSnapshot()
+  })
+
  test('ifNode', () => {
    const { code } = generate(
      createRoot({
@@ -202,6 +223,50 @@ describe('compiler: codegen', () => {
    expect(code).toMatchSnapshot()
  })

+  test('ifNode with no v-else', () => {
+    const { code } = generate(
+      createRoot({
+        children: [
+          {
+            type: NodeTypes.IF,
+            loc: mockLoc,
+            isRoot: true,
+            branches: [
+              {
+                type: NodeTypes.IF_BRANCH,
+                condition: createExpression('foo', false, mockLoc),
+                loc: mockLoc,
+                isRoot: true,
+                children: [
+                  {
+                    type: NodeTypes.TEXT,
+                    content: 'foo',
+                    isEmpty: false,
+                    loc: mockLoc
+                  }
+                ]
+              },
+              {
+                type: NodeTypes.IF_BRANCH,
+                condition: createExpression('bar', false, mockLoc),
+                loc: mockLoc,
+                isRoot: true,
+                children: [createExpression(`bye`, false, mockLoc, true)]
+              }
+            ]
+          }
+        ]
+      })
+    )
+    expect(code).toMatch(`
+    return (foo)
+      ? "foo"
+      : (bar)
+        ? ${TO_STRING}(bye)
+        : null`)
+    expect(code).toMatchSnapshot()
+  })
+
  test('forNode', () => {
    const { code } = generate(
      createRoot({
@@ -222,63 +287,166 @@ describe('compiler: codegen', () => {
    expect(code).toMatchSnapshot()
  })

-  test('callExpression + objectExpression + arrayExpression', () => {
+  test('forNode w/ skipped value alias', () => {
    const { code } = generate(
      createRoot({
        children: [
          {
-            type: NodeTypes.ELEMENT,
+            type: NodeTypes.FOR,
            loc: mockLoc,
-            ns: Namespaces.HTML,
-            tag: 'div',
-            tagType: ElementTypes.ELEMENT,
-            isSelfClosing: false,
-            props: [],
-            children: [],
-            codegenNode: {
-              type: NodeTypes.JS_CALL_EXPRESSION,
-              loc: mockLoc,
-              callee: CREATE_VNODE,
-              arguments: [
-                `"div"`,
+            source: createExpression(`list`, false, mockLoc),
+            valueAlias: undefined,
+            keyAlias: createExpression(`k`, false, mockLoc),
+            objectIndexAlias: createExpression(`i`, false, mockLoc),
+            children: [createExpression(`v`, false, mockLoc, true)]
+          }
+        ]
+      })
+    )
+    expect(code).toMatch(`renderList(list, (__value, k, i) => toString(v))`)
+    expect(code).toMatchSnapshot()
+  })
+
+  test('forNode w/ skipped key alias', () => {
+    const { code } = generate(
+      createRoot({
+        children: [
+          {
+            type: NodeTypes.FOR,
+            loc: mockLoc,
+            source: createExpression(`list`, false, mockLoc),
+            valueAlias: createExpression(`v`, false, mockLoc),
+            keyAlias: undefined,
+            objectIndexAlias: createExpression(`i`, false, mockLoc),
+            children: [createExpression(`v`, false, mockLoc, true)]
+          }
+        ]
+      })
+    )
+    expect(code).toMatch(`renderList(list, (v, __key, i) => toString(v))`)
+    expect(code).toMatchSnapshot()
+  })
+
+  test('forNode w/ skipped value and key aliases', () => {
+    const { code } = generate(
+      createRoot({
+        children: [
+          {
+            type: NodeTypes.FOR,
+            loc: mockLoc,
+            source: createExpression(`list`, false, mockLoc),
+            valueAlias: undefined,
+            keyAlias: undefined,
+            objectIndexAlias: createExpression(`i`, false, mockLoc),
+            children: [createExpression(`v`, false, mockLoc, true)]
+          }
+        ]
+      })
+    )
+    expect(code).toMatch(`renderList(list, (__value, __key, i) => toString(v))`)
+    expect(code).toMatchSnapshot()
+  })
+
+  test('callExpression + objectExpression + arrayExpression', () => {
+    function createElementWithCodegen(
+      args: CallExpression['arguments']
+    ): ElementNode {
+      return {
+        type: NodeTypes.ELEMENT,
+        loc: mockLoc,
+        ns: Namespaces.HTML,
+        tag: 'div',
+        tagType: ElementTypes.ELEMENT,
+        isSelfClosing: false,
+        props: [],
+        children: [],
+        codegenNode: {
+          type: NodeTypes.JS_CALL_EXPRESSION,
+          loc: mockLoc,
+          callee: CREATE_VNODE,
+          arguments: args
+        }
+      }
+    }
+
+    const { code } = generate(
+      createRoot({
+        children: [
+          createElementWithCodegen([
+            // string
+            `"div"`,
+            // ObjectExpression
+            createObjectExpression(
+              [
+                createObjectProperty(
+                  createExpression(`id`, true, mockLoc),
+                  createExpression(`foo`, true, mockLoc),
+                  mockLoc
+                ),
+                createObjectProperty(
+                  createExpression(`prop`, false, mockLoc),
+                  createExpression(`bar`, false, mockLoc),
+                  mockLoc
+                ),
+                // compound expression as computed key
+                createObjectProperty(
+                  {
+                    type: NodeTypes.EXPRESSION,
+                    content: ``,
+                    loc: mockLoc,
+                    isStatic: false,
+                    isInterpolation: false,
+                    children: [
+                      `foo + `,
+                      createExpression(`bar`, false, mockLoc)
+                    ]
+                  },
+                  createExpression(`bar`, false, mockLoc),
+                  mockLoc
+                )
+              ],
+              mockLoc
+            ),
+            // ChildNode[]
+            [
+              createElementWithCodegen([
+                `"p"`,
                createObjectExpression(
                  [
                    createObjectProperty(
-                      createExpression(`id`, true, mockLoc),
+                      // should quote the key!
+                      createExpression(`some-key`, true, mockLoc),
                      createExpression(`foo`, true, mockLoc),
                      mockLoc
-                    ),
-                    createObjectProperty(
-                      createExpression(`prop`, false, mockLoc),
-                      createExpression(`bar`, false, mockLoc),
-                      mockLoc
                    )
                  ],
                  mockLoc
-                ),
-                createArrayExpression(
-                  [
-                    'foo',
-                    {
-                      type: NodeTypes.JS_CALL_EXPRESSION,
-                      loc: mockLoc,
-                      callee: CREATE_VNODE,
-                      arguments: [`"p"`]
-                    }
-                  ],
-                  mockLoc
                )
-              ]
-            }
-          }
+              ])
+            ],
+            // ArrayExpression
+            createArrayExpression(
+              [
+                'foo',
+                {
+                  type: NodeTypes.JS_CALL_EXPRESSION,
+                  loc: mockLoc,
+                  callee: CREATE_VNODE,
+                  arguments: [`"p"`]
+                }
+              ],
+              mockLoc
+            )
+          ])
        ]
      })
    )
    expect(code).toMatch(`
    return ${CREATE_VNODE}("div", {
      id: "foo",
-      [prop]: bar
-    }, [
+      [prop]: bar,
+      [foo + bar]: bar
+    }, [${CREATE_VNODE}("p", { "some-key": "foo" })], [
      foo,
      ${CREATE_VNODE}("p")
    ])`)
--- a/packages/compiler-core/tests/transforms/transformElement.spec.ts
+++ b/packages/compiler-core/tests/transforms/transformElement.spec.ts
@@ -80,6 +80,46 @@ describe('compiler: element transform', () => {
    ])
  })

+  test('props + children', () => {
+    const { node } = parseWithElementTransform(`<div id="foo"><span/></div>`)
+    expect(node.callee).toBe(CREATE_VNODE)
+    expect(node.arguments).toMatchObject([
+      `"div"`,
+      createStaticObjectMatcher({
+        id: 'foo'
+      }),
+      [
+        {
+          type: NodeTypes.ELEMENT,
+          tag: 'span',
+          codegenNode: {
+            callee: CREATE_VNODE,
+            arguments: [`"span"`]
+          }
+        }
+      ]
+    ])
+  })
+
+  test('0 placeholder for children with no props', () => {
+    const { node } = parseWithElementTransform(`<div><span/></div>`)
+    expect(node.callee).toBe(CREATE_VNODE)
+    expect(node.arguments).toMatchObject([
+      `"div"`,
+      `0`,
+      [
+        {
+          type: NodeTypes.ELEMENT,
+          tag: 'span',
+          codegenNode: {
+            callee: CREATE_VNODE,
+            arguments: [`"span"`]
+          }
+        }
+      ]
+    ])
+  })
+
  test('v-bind="obj"', () => {
    const { root, node } = parseWithElementTransform(`<div v-bind="obj" />`)
    // single v-bind doesn't need mergeProps
--- a/packages/compiler-core/tests/transforms/transformExpressions.spec.ts
+++ b/packages/compiler-core/tests/transforms/transformExpressions.spec.ts
@@ -5,16 +5,21 @@ import {
  ElementNode,
  DirectiveNode,
  NodeTypes,
-  ForNode
+  ForNode,
+  CompilerOptions
 } from '../../src'
 import { transformFor } from '../..//src/transforms/vFor'
 import { transformExpression } from '../../src/transforms/transformExpression'

-function parseWithExpressionTransform(template: string) {
+function parseWithExpressionTransform(
+  template: string,
+  options: CompilerOptions = {}
+) {
  const ast = parse(template)
  transform(ast, {
    prefixIdentifiers: true,
-    nodeTransforms: [transformFor, transformExpression]
+    nodeTransforms: [transformFor, transformExpression],
+    ...options
  })
  return ast.children[0]
 }
@@ -297,4 +302,10 @@ describe('compiler: expression transform', () => {
      `]`
    ])
  })
+
+  test('should handle parse error', () => {
+    const onError = jest.fn()
+    parseWithExpressionTransform(`{{ a( }}`, { onError })
+    expect(onError.mock.calls[0][0].message).toMatch(`Expected ')'`)
+  })
 })