1 | import { stat } from 'fs'
|
2 | import {
|
3 | getLatticePrefs,
|
4 | Deferred,
|
5 | promisify,
|
6 | types
|
7 | } from '../es6/lattice'
|
8 |
|
9 | const { extendsFrom } = types;
|
10 |
|
11 | describe('getLatticePrefs should combine defaults with custom value', () => {
|
12 | it('should pick up local package.json "lattice" settings', () => {
|
13 | let options = getLatticePrefs({ cwd: './test' })
|
14 |
|
15 | expect(options).not.toBeNull()
|
16 | expect(options.ModuleParser).toBeDefined()
|
17 | expect(options.ModuleParser.failOnError).toBeTruthy()
|
18 | expect(options.ModuleParser.extensions).toBeDefined()
|
19 | expect(options.ModuleParser.extensions.length).toBe(4)
|
20 | })
|
21 | })
|
22 |
|
23 | describe('Deferred should allow promise to be inverted', async () => {
|
24 | it('should simply allow inverted promises', async () => {
|
25 | let deferred = new Deferred()
|
26 |
|
27 | expect(deferred.resolve).toBeDefined()
|
28 | expect(deferred.reject).toBeDefined()
|
29 | expect(deferred.pending).toBeTruthy()
|
30 | expect(deferred.complete).toBeFalsy()
|
31 |
|
32 | deferred.resolve(true)
|
33 |
|
34 | expect(deferred.pending).toBeFalsy()
|
35 | expect(deferred.complete).toBeTruthy()
|
36 | expect(async () => {
|
37 | let value = await deferred.promise
|
38 | expect(value).toBe(true)
|
39 | }).not.toThrow()
|
40 | })
|
41 |
|
42 | it('should allow setting auto resolve value', async () => {
|
43 | let deferred = new Deferred(42)
|
44 |
|
45 | expect(deferred.resolve).toBeDefined()
|
46 | expect(deferred.reject).toBeDefined()
|
47 | expect(deferred.complete).toBeTruthy()
|
48 | expect(deferred.pending).toBeFalsy()
|
49 |
|
50 | try {
|
51 | let meaningOfLife = await deferred.promise
|
52 |
|
53 | expect(meaningOfLife).toBe(42)
|
54 | }
|
55 | catch (shouldNotBeHere) {
|
56 | expect(false).toBe(true)
|
57 | }
|
58 | })
|
59 |
|
60 | it('should allow setting auto reject value', async () => {
|
61 | let deferred = new Deferred(undefined, 42)
|
62 | let meaningOfLife
|
63 |
|
64 | expect(deferred.resolve).toBeDefined()
|
65 | expect(deferred.reject).toBeDefined()
|
66 | expect(deferred.complete).toBeTruthy()
|
67 | expect(deferred.pending).toBeFalsy()
|
68 |
|
69 | try {
|
70 | meaningOfLife = await deferred.promise
|
71 | expect(true).toBe(false)
|
72 | }
|
73 | catch (ignore) {
|
74 | expect(deferred.pending).toBeFalsy()
|
75 | expect(deferred.complete).toBeTruthy()
|
76 | expect(meaningOfLife).toBe(undefined)
|
77 | }
|
78 | })
|
79 |
|
80 | it('time deferreds should reject after specified time', async () => {
|
81 | let deferred = Deferred.TimedDeferred(100)
|
82 | let value = null
|
83 |
|
84 | expect(deferred.resolve).toBeDefined()
|
85 | expect(deferred.reject).toBeDefined()
|
86 | expect(deferred.pending).toBeTruthy()
|
87 | expect(deferred.complete).toBeFalsy()
|
88 |
|
89 | try {
|
90 | value = await deferred.promise
|
91 | }
|
92 | catch (ignore) {
|
93 | expect(deferred.pending).toBeFalsy()
|
94 | expect(deferred.complete).toBeTruthy()
|
95 | }
|
96 |
|
97 | expect(value).toBe(null)
|
98 | })
|
99 | })
|
100 |
|
101 | describe('Sample promisify should work similar to node 8+ version', () => {
|
102 | function contrived(callback) {
|
103 | if (this.valueOf() === 5)
|
104 | callback(null, true)
|
105 | else
|
106 | callback(new Error('Not 5'))
|
107 | }
|
108 |
|
109 | let aStat = promisify(stat)
|
110 | let aContrived = promisify(contrived, Number(5))
|
111 | let aContrived2 = promisify(contrived, Number(6))
|
112 |
|
113 | it('should make aStat return a promise with results', async () => {
|
114 | try {
|
115 | let stats = await aStat('./package.json')
|
116 |
|
117 | expect(stats).toBeDefined()
|
118 | expect(stats.size).toBeGreaterThan(0)
|
119 | }
|
120 | catch (error) {
|
121 | expect(false).toBe(true)
|
122 | }
|
123 | })
|
124 |
|
125 | it('should work with custom expected context as well', async () => {
|
126 | try {
|
127 | let bool = await aContrived()
|
128 |
|
129 | expect(bool).toBe(true)
|
130 | }
|
131 | catch (error) {
|
132 | console.error(error)
|
133 | expect(false).toBe(true)
|
134 | }
|
135 | })
|
136 |
|
137 | it('should throw with custom unexpected context', async () => {
|
138 | try {
|
139 | let bool = await aContrived2()
|
140 | expect(true).toBe(false)
|
141 | }
|
142 | catch (error) {
|
143 | expect(error.message).toEqual('Not 5')
|
144 | }
|
145 | })
|
146 | })
|
147 |
|
148 | describe('extendsFrom', () => {
|
149 | class A {}
|
150 | class B extends A {}
|
151 | class C {}
|
152 | class D extends B {}
|
153 |
|
154 | it('should determine if a class extends another', () => {
|
155 | expect(extendsFrom(C, A)).toBe(false);
|
156 | expect(extendsFrom(B, A)).toBe(true);
|
157 | expect(extendsFrom(D, A)).toBe(true);
|
158 | });
|
159 |
|
160 | it('should not throw errors w/ nulls', () => {
|
161 | expect(() => {
|
162 | extendsFrom(null, A);
|
163 | }).not.toThrow();
|
164 |
|
165 | expect(() => {
|
166 | extendsFrom(A, null);
|
167 | }).not.toThrow();
|
168 |
|
169 | expect(() => {
|
170 | extendsFrom(null, null);
|
171 | }).not.toThrow();
|
172 | });
|
173 | });
|