Promise.uts

import { describe, test, expect, Result } from './tests.uts'

export function testPromise(): Result {
    return describe("Promise", () => {
        // #ifdef APP-IOS
        test('constructor', () => {
          // 常规方式
           let p = new Promise<number>((resolve, reject) => {
             let success = true;
              setTimeout(()=>{
                if (success) {
                  resolve(2024)
                } else{
                  let error = new Error("something going wrong")
                  reject(error)
                }
              }, 10);
           });
           p.then((res: number) => {  
              expect(res).toEqual(2024) 
           })
           
           // 单个函数
           let p1 = new Promise<any | null>((resolve: (value: any | null) => void) => {
             setTimeout(function() {
               resolve(null)
             }, 10);
           })
           p1.then((res: any | null) => {
              expect(res).toEqual(null) 
           })
           
           // 指定函数类型
           let p2 = new Promise((resolve: (value: string) => void, reject: (error: any | null) => void) => {
              setTimeout(function() {
                reject(null)
              }, 10);
           })
           p2.then()
           .catch((error: any | null) => {
             expect(error).toEqual(null) 
           })
        })
        
        test('then', () => {
            let p = new Promise<string>((reslove, reject) => {
            	setTimeout(function() {
                reslove("hello world")  
            	}, 13);
            })
              
            p.then(
            	(res: string): Promise<string> => {
                expect(res).toEqual("hello world") 
            		let p0 = new Promise<string>((reslove,reject) => {
            			var success = true;  
            			setTimeout(function() {
            				success = true;
            				if (success) {
            					reslove(res + " 2024")  
            				} else{
            					reject("first then p0 reject message")
            				}
            			}, 8);
            		})
            		return p0;
            	},
            	(err: any | null): void => {  
            		throw new Error("first then throw error")
            	}
            )
            .catch(
            	(err):string => {
            		return "first catch return message"
            	}
            )   
            .then(
            	(res) => {
                console.log(res)
                expect(res).toEqual("hello world 2024") 
            	}
            )
            .catch(
            	(err) => {
            		console.log(err, "this is seconded catch")
            	}
            )  
            .finally(() => {
              console.log("finally")
              expect("finally").toEqual("finally")
            })
        })
        
        test('catch', () => {
            let p = Promise.reject()
            p.then()
            .catch((res: any | null) => {
              expect(res).toEqual(null)
            })
            
            // catch 指定返回值
            new Promise<string>((resolve, reject) => {
              setTimeout(() => {
                reject("2024")
              }, 12)
            })
            .then()
            .catch((res: any | null): string => {
              expect(res!).toEqual("2024")
              return "hello world"
            })
            .then((res) => {
              expect(res).toEqual("hello world")
            })
            
            // catch 返回Promise
             new Promise<string>((resolve, reject) => {
              setTimeout(() => {
                reject("2024")
              }, 12)
            })
            .then()
            .catch((res: any | null): Promise<number> => {
              expect(res!).toEqual("2024")
              let p = new Promise<number>((resolve, reject) => {
                resolve(1)
              })
              return p
            })
            .then((res) => {
              expect(res).toEqual(1)
            })
        })
        
        test('finally', () => {
            Promise.resolve(2)
            .finally(() => {
              console.log("finally")
            })
            .then((res) => {
              expect(res).toEqual(2)
            })
            
            Promise.reject(3)
            .finally(() => {
              console.log("finally")
            })
            .catch((res) => {
              expect(res).toEqual(3)
            })
            
            Promise.resolve(2)
            .finally((): number => {
              console.log("finally")
              return 88
            })
            .then((res) => {
            	expect(res).toEqual(2)
            })
            
            Promise.reject(3).finally(() => {
            	throw new Error("99")
            })
            .catch((res) => {
              expect((res as Error).message).toEqual("99");
            })
            
            console.log("start");
            Promise.reject(4).finally((): Promise<number> => {
            	return new Promise((resolve, reject) => {
            		setTimeout(() => {
            			resolve(20)
            		}, 1000)
            	})
            })
            .catch((res) => {
            	expect(res).toEqual(4)
            })
        })
        
        test('resolve', () => {
          // resolve array
          Promise.resolve([1,2,3])
          .then((res) => {
            expect(res).toEqual([1,2,3])
          })
          
          // resolve string
          Promise.resolve("成功")
          .then((res) => {
            expect(res).toEqual("成功");
          })
          
          // resolve null
          Promise.resolve()
          .then((res) => {
            // expect(res).toEqual(null);
          })
          
          // resolve promise
          const original = Promise.resolve(33)
          const cast = Promise.resolve(original)
          cast.then((res) => {
            expect(res).toEqual(33);
          })
          // 注：此处飘红是编译器误报，实际可以判等
          expect(original === cast).toEqual(true)
        })
        
        test('reject', () => {
          // reject array
          Promise.reject([1,2,3])
          .catch((err) => {
            expect(err).toEqual([1,2,3])
          })
          
          // reject error
          Promise.reject(new Error("this is reject error message"))
          .catch((err) => {
            expect((err as Error).message).toEqual("this is reject error message");
          })
          
          // reject null
          Promise.reject()
          .catch((err) => {
            expect(err).toEqual(null);
          })
          
          // reject promise
          const original = Promise.reject(33)
          const cast = Promise.reject(original)
          cast.catch((err) => {
            expect((err as Promise<any>) === original).toEqual(true);
          })
          expect(original === cast).toEqual(false)
          
        })
        
        test('all', () => {
           let p0 = new Promise<string>((resolve, reject) => {
             setTimeout(function() {
               resolve("1");
             }, 10);
           })
           
           let p1 = new Promise<string>((resolve, reject) => {
             setTimeout(function() {
               resolve("2");
             }, 10);
           })
           
           let p2 = new Promise<string>((resolve, reject) => {
             setTimeout(function() {
               resolve("3");
             }, 10);
           })
           
           let p3 = new Promise<string>((resolve, reject) => {
             setTimeout(function() {
               let error = new Error("p3 reject reason")
               reject(error);
             }, 10);
           })
           // resolve
           Promise.all([p0, p1, p2])
           .then((res) => {
             console.log(res);
             expect(res).toEqual(["1", "2", "3"]) 
           })
           
           // reject
           Promise.all([p1, p2, p3])
           .then()
           .catch((error) => {
             console.log(error);
             expect((error as Error).message).toEqual("p3 reject reason");
           })
        })
        
        test('allSettled', () => {
            let p0 = new Promise<string | null>((resolve, reject) => {
              setTimeout(function() {
                resolve("1");
              }, 10);
            })
            
            let p1 = new Promise<string | null>((resolve, reject) => {
              setTimeout(function() {
                resolve(null);
              }, 10);
            })
            
            let p2 = new Promise<string | null>((resolve, reject) => {
              setTimeout(function() {
                reject(null)
              }, 10);
            })
            
            let p3 = new Promise<string  | null>((resolve, reject) => {
              setTimeout(function() {
                let error = new Error("p3 reject reason")
                reject(error);
              }, 10);
            })
            
            Promise.allSettled([p0, p1, p2, p3])
            .then((res) => {
              console.log(res);
              let statusArr : string[] = []
              res.forEach((item, index) => {
                statusArr.append(item.status)
              })
              expect(statusArr).toEqual(["fulfilled", "fulfilled", "rejected", "rejected"]) 
            })
        })
        
        test('any', () => {
          let p0 = new Promise<string | null>((resolve, reject) => {
            setTimeout(function() {
              resolve("1");
            }, 10);
          })
          
          let p1 = new Promise<string | null>((resolve, reject) => {
            setTimeout(function() {
              resolve(null);
            }, 15);
          })
          
          let p2 = new Promise<string | null>((resolve, reject) => {
            setTimeout(function() {
              reject(null)
            }, 10);
          })
          
          let p3 = new Promise<string  | null>((resolve, reject) => {
            setTimeout(function() {
             reject("error");
            }, 12);
          })
          
          // test for resolve
          Promise.any([p0, p1, p2])
          .then((res) => {
            console.log(res)
            expect(res).toEqual("1");
          })
          
          // test for reject
          Promise.any([p2, p3])
          .then()
          .catch(
            (error: any | null) => {
              console.log("test for promise.any error ==> ", error);
              expect((error as UTSPromiseAggregateError).name).toEqual("AggregateError");
              expect((error as UTSPromiseAggregateError).message).toEqual("All promises were rejected");
              expect((error as UTSPromiseAggregateError).errors).toEqual([null, "error"]);
          })   
        })
        
        test('race', () => {
          let p0 = new Promise<string | null>((resolve, reject) => {
            setTimeout(function() {
              resolve("fast");
            }, 10);
          })
          
          let p1 = new Promise<string | null>((resolve, reject) => {
            setTimeout(function() {
              resolve("slow");
            }, 15);
          })
          
          let p2 = new Promise<string | null>((resolve, reject) => {
            setTimeout(function() {
              reject(null)
            }, 12);
          })
          
          // test for resolve
          Promise.race([p0, p1])
          .then((res) => {
            console.log("test for race resolve ===> ", res);
            expect(res).toEqual("fast");
          })
          
          // test for reject 
          Promise.race([p1, p2])
          .then()
          .catch((error) => {
            console.log("test for race reject ===> ", error);
            expect(error).toEqual(null);
          })
        })
        // #endif
    })
}