test

Author: ruojianll

src/component.ts

@@ -53,7 +53,7 @@ type ComponentOption = {
     provide?: Record<string, any> | Function
     components?: Record<string, any>
     directives?: Record<string, any>;
-    inheritAttrs?: boolean;
+    inheritAttrs?: true;
     expose?: string[];
     modifier?: (raw: any) => any
 }

test/component.ts

@@ -8,18 +8,61 @@ export class Empty extends Base {
 
 }
 const EmptyContext = Empty as any
+
+const FullOptionOpt = {
+  name: 'FullOption',
+  emits: ['emits1', 'emits2'],
+  provide: function () {
+    return 'provided'
+  },
+  components: {
+    empty: Empty
+  },
+  directives: {
+    directive: {
+      directiveFlag: {}
+    }
+  },
+  inheritAttrs: true,
+  expose: ['expose1', 'expose2'],
+  modifier(option: any) {
+    option.emits.push('emits3')
+    return option
+  }
+}
+
+@Component(FullOptionOpt)
+export class FullOption extends Base {
+
+}
+const FullOptionContext = FullOption as any
 describe('Component',
-  () => describe('Empty', () => {
-    it('Should be empty', () => {
+  () => {
+    it('Empty', () => {
+      expect('object').to.equal(typeof EmptyContext)
       Object.keys(EmptyContext).forEach(key => {
-        if(key==='data' && typeof EmptyContext[key]==='function'){
+        if (key === 'data' && typeof EmptyContext[key] === 'function') {
           expect(true).to.equal(isEmptyObject(EmptyContext[key]()))
-        }else{
+        } else {
           expect(true).to.equal(isEmptyObject(EmptyContext[key]))
         }
       })
     })
-  })
+    it('Full option', () => {
+      expect('object').to.equal(typeof FullOptionContext)
+      Object.keys(FullOptionOpt).forEach(key => {
+        const opt = (FullOptionOpt as any)[key]
+        switch (key) {
+          case 'emits':
+            expect([...opt, 'emits3'].join(',')).to.equal(FullOptionContext[key].join(','))
+            break;
+          case 'modifier':
+            return;
+          default:
+            expect(opt).to.equal(FullOptionContext[key])
+        }
+      })
+    })
+  }
 )
-
 export default {}

test/feature/classExtends.ts

@@ -0,0 +1,53 @@
+
+import { expect } from 'chai';
+import 'mocha';
+import { Component, Base } from '../../dist'
+class Sup extends Base {
+    dataSup = 'dataSup value'
+    data = 'data-sup value'
+    methodSup() {
+        return 'methodSup value'
+    }
+    method() {
+        return 'method-sup value'
+    }
+    mounted() {
+        return 'mounted-sup value'
+    }
+}
+@Component
+export class Comp extends Sup {
+    dataComp = 'dataComp value'
+    data = 'data-comp value'
+    methodComp() {
+        return 'methodComp value'
+    }
+    method() {
+        return 'method-comp value'
+    }
+    mounted() {
+        return 'mounted-comp value'
+    }
+}
+const CompContext = Comp as any
+
+describe('feature class extends',
+    () => {
+        it('default', () => {
+            expect('function').to.equal(typeof CompContext?.methods?.method)
+            expect('method-comp value').to.equal(CompContext.methods.method())
+            expect('function').to.equal(typeof CompContext?.methods?.methodComp)
+            expect('methodComp value').to.equal(CompContext.methods.methodComp())
+            expect('function').to.equal(typeof CompContext?.methods?.methodSup)
+            expect('methodSup value').to.equal(CompContext.methods.methodSup())
+            expect('function').to.equal(typeof CompContext?.data)
+            const data = CompContext.data()
+            expect('data-comp value').to.equal(data.data)
+            expect('dataComp value').to.equal(data.dataComp)
+            expect('dataSup value').to.equal(data.dataSup)
+            expect('function').to.equal(typeof CompContext?.mounted)
+            expect('mounted-comp value').to.equal(CompContext.mounted())
+        })
+    }
+)
+export default {}

test/feature/componentExtends.ts

@@ -0,0 +1,45 @@
+
+import { expect } from 'chai';
+import 'mocha';
+import { Component, ComponentBase, Base } from '../../dist'
+@ComponentBase
+class Sup extends Base {
+    dataSup = 'dataSup value'
+    methodSup(){
+        return 'methodSup value'
+    }
+}
+@Component
+export class Comp extends Sup {
+    dataComp = 'dataComp value'
+    methodComp(){
+        return 'methodComp value'
+    }
+}
+
+const CompContext = Comp as any
+const SupContext = CompContext.extends
+describe('feature component extends',
+    () => {
+        it('comp', () => {
+            expect('function').to.equal(typeof CompContext?.data)
+            const compData = CompContext.data()
+            expect('dataComp value').to.equal(compData.dataComp)
+            expect('function').to.equal(typeof CompContext?.methods?.methodComp)
+            expect('methodComp value').to.equal(CompContext.methods.methodComp())
+
+        
+
+
+        })
+        it('sup',()=>{
+            expect('object').to.equal(typeof SupContext)
+            expect('function').to.equal(typeof SupContext?.data)
+            const supData = SupContext.data()
+            expect('dataSup value').to.equal(supData.dataSup)
+            expect('function').to.equal(typeof SupContext?.methods?.methodSup)
+            expect('methodSup value').to.equal(SupContext.methods.methodSup())
+        })
+    }
+)
+export default {}

test/feature/extends.ts

@@ -0,0 +1,75 @@
+
+import { expect } from 'chai';
+import 'mocha';
+import { Component, ComponentBase, Base } from '../../dist'
+
+class Comp1Sup extends Base {
+    method1Sup() {
+        return 'method1Sup value'
+    }
+}
+
+@ComponentBase
+class Comp1 extends Comp1Sup {
+    method1Comp() {
+        return 'method1Comp value'
+    }
+}
+
+class Comp2Sup extends Comp1 {
+    method2Sup() {
+        return 'method2Sup value'
+    }
+}
+
+@ComponentBase
+class Comp2 extends Comp2Sup {
+    method2Comp() {
+        return 'method2Comp value'
+    }
+}
+
+class Comp3Sup extends Comp2 {
+    method3Sup() {
+        return 'method3Sup value'
+    }
+}
+
+
+@Component
+class Comp3 extends Comp3Sup {
+    method3Comp() {
+        return 'method3Comp value'
+    }
+}
+
+const Comp3Context = Comp3 as any
+
+describe('feature extends',
+    () => {
+        const Comp2Context = Comp3Context.extends
+        expect('object').to.equal(typeof Comp2Context)
+        const Comp1Context = Comp2Context.extends
+        expect('object').to.equal(typeof Comp1Context)
+        expect('undefined').to.equal(typeof Comp1Context.extends)
+        it('comp3', () => {
+            expect('function').to.equal(typeof Comp3Context?.methods?.method3Comp)
+            expect('method3Comp value').to.equal(Comp3Context.methods.method3Comp())
+            expect('function').to.equal(typeof Comp3Context?.methods?.method3Sup)
+            expect('method3Sup value').to.equal(Comp3Context.methods.method3Sup())
+        })
+        it('comp2', () => {
+            expect('function').to.equal(typeof Comp2Context?.methods?.method2Comp)
+            expect('method2Comp value').to.equal(Comp2Context.methods.method2Comp())
+            expect('function').to.equal(typeof Comp2Context?.methods?.method2Sup)
+            expect('method2Sup value').to.equal(Comp2Context.methods.method2Sup())
+        })
+        it('comp1', () => {
+            expect('function').to.equal(typeof Comp1Context?.methods?.method1Comp)
+            expect('method1Comp value').to.equal(Comp1Context.methods.method1Comp())
+            expect('function').to.equal(typeof Comp1Context?.methods?.method1Sup)
+            expect('method1Sup value').to.equal(Comp1Context.methods.method1Sup())
+        })
+    }
+)
+export default {}

test/feature/lifecycle.ts

@@ -0,0 +1,24 @@
+
+import { expect } from 'chai';
+import 'mocha';
+import { Component, Ref, Base } from '../../dist'
+
+@Component
+export class Comp extends Base {
+    mounted(){
+        return 'mounted test value'
+    }
+
+}
+const CompContext = Comp as any
+
+describe('feature lifecycle',
+    () => {
+        it('default', () => {
+            expect('undefined').to.equal(typeof CompContext?.methods?.mounted)
+            expect('function').to.equal(typeof CompContext?.mounted)
+            expect('mounted test value').to.equal(CompContext?.mounted())
+        })
+    }
+)
+export default {}

test/internal/utils.ts

@@ -0,0 +1,95 @@
+
+import { expect } from 'chai';
+import 'mocha';
+import { Base } from '../../dist'
+import * as Utils from '../../dist/utils'
+
+
+class Comp1Sup extends Base {
+    method1Sup() {
+        return 'method1Sup value'
+    }
+}
+
+
+class Comp1 extends Comp1Sup {
+    method1Comp() {
+        return 'method1Comp value'
+    }
+}
+
+class Comp2Sup extends Comp1 {
+    method2Sup() {
+        return 'method2Sup value'
+    }
+}
+
+
+class Comp2 extends Comp2Sup {
+    method2Comp() {
+        return 'method2Comp value'
+    }
+}
+
+class Comp3Sup extends Comp2 {
+    method3Sup() {
+        return 'method3Sup value'
+    }
+}
+
+
+
+class Comp3 extends Comp3Sup {
+    method3Comp() {
+        return 'method3Comp value'
+    }
+}
+
+describe('internal utils',
+    () => {
+        it('slot', () => {
+            expect(true).to.equal(Utils.obtainSlot(Comp3.prototype).names instanceof Map)
+        })
+        it('toComponentReverse', () => {
+            Utils.obtainSlot(Comp2.prototype)
+            Utils.obtainSlot(Comp1.prototype)
+
+            const path3 = Utils.toComponentReverse(Comp3.prototype)
+
+            expect(2).to.equal(path3.length)
+
+            expect(Comp3Sup).to.equal(path3[0].constructor)
+            expect(true).to.equal(path3[0] instanceof Comp2)
+
+            expect(Comp3).to.equal(path3[1].constructor)
+            expect(true).to.equal(path3[1] instanceof Comp3Sup)
+
+            const path2 = Utils.toComponentReverse(Comp2.prototype)
+            expect(2).to.equal(path2.length)
+
+            expect(Comp2Sup).to.equal(path2[0].constructor)
+            expect(true).to.equal(path2[0] instanceof Comp1)
+
+            expect(Comp2).to.equal(path2[1].constructor)
+            expect(true).to.equal(path2[1] instanceof Comp2Sup)
+
+            const path1 = Utils.toComponentReverse(Comp1.prototype)
+            expect(2).to.equal(path1.length)
+
+            expect(Comp1Sup).to.equal(path1[0].constructor)
+            expect(true).to.equal(path1[0] instanceof Base)
+
+            expect(Comp1).to.equal(path1[1].constructor)
+            expect(true).to.equal(path1[1] instanceof Comp1Sup)
+        })
+
+        it('extendSlotPath', () => {
+            const path = Utils.extendSlotPath(Comp3.prototype)
+            expect(3).to.equal(path.length)
+            expect(Comp3.prototype).to.equal(path[0])
+            expect(Comp2.prototype).to.equal(path[1])
+            expect(Comp1.prototype).to.equal(path[2])
+        })
+    }
+)
+export default {}