@tarojs/taro-rn 4.0.0-beta.78 → 4.0.0-beta.79

package/src/__tests__/media.test.ts

@@ -0,0 +1,104 @@
+import { getImageInfo } from '../lib/getImageInfo'
+import { saveImageToPhotosAlbum } from '../lib/saveImageToPhotosAlbum'
+import { saveVideoToPhotosAlbum } from '../lib/saveVideoToPhotosAlbum'
+
+const Taro = {
+  getImageInfo,
+  saveImageToPhotosAlbum,
+  saveVideoToPhotosAlbum,
+}
+
+// 原生模块导出缺少 react_native_1.NativeModules.RNCCameraRoll setup mock
+
+describe('media', () => {
+  describe('getImageInfo', () => {
+    test('能正确获取图片信息', () => {
+      const url = 'https://img12.360buyimg.com/ling/jfs/t19387/224/2632923601/58290/3bbe4eda/5b03f63cN17d4a46c.png'
+      const width = 320
+      const height = 240
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      expect.assertions(8)
+      return Taro.getImageInfo({
+        src: url,
+        success,
+        fail,
+        complete
+      }).then((res) => {
+        const expectRes = {
+          width,
+          height,
+          path: url,
+          orientation: 'up',
+          type: ''
+        }
+        expect(success.mock.calls.length).toBe(1)
+        expect(success.mock.calls[0][0]).toMatchObject(expectRes)
+        expect(fail.mock.calls.length).toBe(0)
+        expect(complete.mock.calls.length).toBe(1)
+        expect(complete.mock.calls[0][0]).toMatchObject(expectRes)
+        expect(res.width).toEqual(width)
+        expect(res.height).toEqual(height)
+        expect(res.path).toEqual(url)
+      })
+    })
+  })
+
+  describe('saveImageToPhotosAlbum', () => {
+    test('能够正常保存图片', () => {
+      const url = 'test.io/a.png'
+      const expectMsg = 'saveImageToPhotosAlbum:ok'
+
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      expect.assertions(6)
+      return Taro.saveImageToPhotosAlbum({
+        filePath: url,
+        success,
+        fail,
+        complete
+      }).then((res) => {
+        const path = `photo://${url}`
+        expect(success.mock.calls.length).toBe(1)
+        expect(success.mock.calls[0][0]).toEqual({ errMsg: expectMsg, path })
+        expect(fail.mock.calls.length).toBe(0)
+        expect(complete.mock.calls.length).toBe(1)
+        expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectMsg, path })
+        // @ts-ignore
+        expect(res.path).toEqual(path)
+      })
+    })
+  })
+
+  describe('saveVideoToPhotosAlbum', () => {
+    test('能够正常保存视频', () => {
+      const url = 'test.io/a.mp4'
+      const expectMsg = 'saveVideoToPhotosAlbum:ok'
+
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      expect.assertions(6)
+      return Taro.saveVideoToPhotosAlbum({
+        filePath: url,
+        success,
+        fail,
+        complete
+      }).then((res) => {
+        const path = `video://${url}`
+        expect(success.mock.calls.length).toBe(1)
+        expect(success.mock.calls[0][0]).toEqual({ errMsg: expectMsg, path })
+        expect(fail.mock.calls.length).toBe(0)
+        expect(complete.mock.calls.length).toBe(1)
+        expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectMsg, path })
+        // @ts-ignore
+        expect(res.path).toEqual(path)
+      })
+    })
+  })
+})

package/src/__tests__/network.test.ts

@@ -0,0 +1,57 @@
+import * as network from '../lib/network'
+const Taro = Object.assign({}, network)
+
+describe('network', () => {
+  describe('getNetworkType', () => {
+    test('能正常返回网络类型', () => {
+      const networkType = expect.any(String)
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      return Taro.getNetworkType({
+        success,
+        fail,
+        complete
+      }).then((res) => {
+        expect.assertions(6)
+        expect(success.mock.calls.length).toBe(1)
+        expect(success.mock.calls[0][0]).toEqual({ networkType, errMsg: 'getNetworkType:ok' })
+        expect(fail.mock.calls.length).toBe(0)
+        expect(complete.mock.calls.length).toBe(1)
+        expect(complete.mock.calls[0][0]).toEqual({ networkType, errMsg: 'getNetworkType:ok' })
+        expect(res.networkType).toEqual(networkType)
+      })
+    })
+  })
+  // mock react_native_1.NativeModules.RNCNetInfo 暂不mock 内部实现，比如事件的发布订阅
+  // describe('onNetworkStatusChange', () => {
+  //   test('能够正常监听网络状态的变化', done => {
+  //     const networkType = '3g'
+  //     const networkCb = (res) => {
+  //       expect(res).toEqual({ networkType, isConnected: true })
+  //       done()
+  //     }
+  //     expect.assertions(1)
+
+  //     Taro.onNetworkStatusChange(networkCb)
+  //     NetInfo.changeNetworkType('cellular', networkType)
+  //     NetInfo.fetch().then(state => {
+  //       console.log("Connection type", state.type)
+  //       console.log("Is connected?", state.isConnected)
+  //     })
+  //   })
+
+  //   test('能返回正确的关于网络状态的判断', done => {
+  //     const networkType = 'none'
+  //     const networkCb = (res) => {
+  //       expect(res).toEqual({ networkType, isConnected: false })
+  //       done()
+  //     }
+  //     expect.assertions(1)
+
+  //     Taro.onNetworkStatusChange(networkCb)
+  //     NetInfo.changeNetworkType('none')
+  //   })
+  // })
+})

package/src/__tests__/others.test.ts

@@ -0,0 +1,25 @@
+import { base64ToArrayBuffer } from '../lib/base64ToArrayBuffer'
+import { arrayBufferToBase64 } from '../lib/arrayBufferToBase64'
+
+const Taro = { base64ToArrayBuffer, arrayBufferToBase64 }
+
+describe('base64 and arrayBuffer', () => {
+  describe('arrayBufferToBase64', () => {
+    test('能正常转换为base64', () => {
+      const expectBase64 = 'CxZY'
+      const arrayBuffer = new Uint8Array([11, 22, 88])
+      const base64 = Taro.arrayBufferToBase64(arrayBuffer)
+      expect(base64).toBe(expectBase64)
+    })
+  })
+
+  describe('base64ToArrayBuffer', () => {
+    test('能正常转换为ArrayBuffer', () => {
+      const base64 = 'CxZY'
+      const arrayBuffer = Taro.base64ToArrayBuffer(base64)
+      expect(arrayBuffer[0]).toBe(11)
+      expect(arrayBuffer[1]).toBe(22)
+      expect(arrayBuffer[2]).toBe(88)
+    })
+  })
+})

package/src/__tests__/phone.test.ts

@@ -0,0 +1,31 @@
+import * as phone from '../lib/makePhoneCall'
+
+const Taro = Object.assign({}, phone)
+
+describe('phone', () => {
+  describe('makePhoneCall', () => {
+    test('能正常调用电话功能', () => {
+      const phoneNumber = '12345678911'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      expect.assertions(6)
+
+      return Taro.makePhoneCall({
+        phoneNumber,
+        success,
+        fail,
+        complete
+      }).then((res) => {
+        const expectMsg = 'makePhoneCall:ok'
+        expect(success.mock.calls.length).toBe(1)
+        expect(success.mock.calls[0][0]).toEqual({ errMsg: expectMsg })
+        expect(fail.mock.calls.length).toBe(0)
+        expect(complete.mock.calls.length).toBe(1)
+        expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectMsg })
+        expect(res.errMsg).toMatch(expectMsg)
+      })
+    })
+  })
+})

package/src/__tests__/request.test.ts

@@ -0,0 +1,146 @@
+import * as request from '../lib/request'
+
+const Taro = Object.assign({}, request)
+
+describe('request', () => {
+  beforeEach(() => {
+    const fetch = jest.fn(() => {
+      return new Promise((resolve) => {
+        resolve({
+          ok: true,
+          status: 200,
+          headers: {},
+          json: () => {
+            return Promise.resolve({ data: 'calorie' })
+          },
+          text: () => {
+            return Promise.resolve('卡路里卡路里卡路')
+          }
+        })
+      })
+    })
+    // @ts-ignore
+    global.fetch = fetch
+  })
+
+  describe('request', () => {
+    // taro@3 不支持
+    // test('直接传入url时能正常返回', async () => {
+    //   const expectData = { data: 'calorie' }
+
+    //   const url = 'https://test.taro.com/v1'
+    //   const res = await Taro.request(url)
+
+    //   expect(res.data).toEqual(expectData)
+    // })
+
+    test('接口数据返回json对象', async () => {
+      const expectData = { data: 'calorie' }
+
+      const url = 'https://test.taro.com/v1'
+      const options = {
+        url,
+        dataType: 'json'
+      }
+      const res = await Taro.request(options)
+
+      expect(res.data).toEqual(expectData)
+    })
+
+    test('接口数据返回text', async () => {
+      const expectData = { data: 'calorie' }
+
+      const url = 'https://test.taro.com/v1'
+      const options = {
+        url,
+        responseType: 'text'
+      }
+      // @ts-ignore
+      const res = await Taro.request(options)
+      expect(res.data).toEqual(expectData)
+    })
+
+    it('RN请求入参同于微信小程序', () => {
+      const url = 'https://test.taro.com/v1'
+      const expectData = JSON.stringify({ data: 'calorie' })
+      const options = {
+        url,
+        dataType: 'json',
+        complete: jest.fn(),
+        success: (res) => {
+          expect(JSON.stringify(res.data)).toMatch(expectData)
+        },
+        fail: jest.fn()
+      }
+      Taro.request(options)
+    })
+
+    test('数据被序列化', async () => {
+      const fetch = jest.fn((url, params) => {
+        return new Promise((resolve) => {
+          resolve({
+            ok: true,
+            status: 200,
+            headers: {},
+            json: () => {
+              return Promise.resolve({ url, params })
+            },
+            text: () => {
+              return Promise.resolve('卡路里卡路里卡路')
+            }
+          })
+        })
+      })
+      // @ts-ignore
+      global.fetch = fetch
+
+      const url = 'https://test.taro.com/v1'
+      const optionsOne = {
+        url,
+        dataType: 'json',
+        data: {
+          a: 1
+        }
+      }
+
+      const expectUrl = `https://test.taro.com/v1?${encodeURIComponent('a')}=${encodeURIComponent(1)}`
+      // @ts-ignore
+      const res = await Taro.request(optionsOne)
+      expect(res.data.url).toMatch(expectUrl)
+
+      const optionsTwo = {
+        url,
+        method: 'post',
+        dataType: 'json',
+        header: {
+          'content-type': 'application/json;charset=UTF-8'
+        },
+        data: {
+          a: 1
+        }
+      }
+
+      const expectBodyOne = JSON.stringify({ a: 1 })
+      // @ts-ignore
+      const resTwo = await Taro.request(optionsTwo)
+      expect(resTwo.data.params.body).toMatch(expectBodyOne)
+
+      const optionsThree = {
+        url,
+        method: 'POST',
+        dataType: 'json',
+        header: {
+          'content-type': 'application/x-www-form-urlencoded'
+        },
+        data: {
+          a: 1
+        }
+      }
+
+      const expectBodyTwo = `${encodeURIComponent('a')}=${encodeURIComponent(1)}`
+      // @ts-ignore
+      const resThree = await Taro.request(optionsThree)
+      expect(resThree.data.params.body).toMatch(expectBodyTwo)
+    })
+  })
+})

package/src/__tests__/scanCode.test.tsx

@@ -0,0 +1,14 @@
+import React from 'react'
+import { RootSiblingParent } from 'react-native-root-siblings';
+import { render, waitFor } from '@testing-library/react-native';
+import { scanCode } from '../lib/scanCode'
+
+describe('scanCode', () => {
+  it('should render scanCode success', async () => {
+    // @ts-ignore
+    const { toJSON, getByLabelText } = render(<RootSiblingParent />)
+    scanCode()
+    await waitFor(() => getByLabelText('Close'));
+    expect(toJSON()).toMatchSnapshot()
+  })
+})

package/src/__tests__/storage.test.ts

@@ -0,0 +1,202 @@
+import AsyncStorage from '@react-native-async-storage/async-storage'
+import { setStorage } from '../lib/setStorage'
+import { getStorage } from '../lib/getStorage'
+import { clearStorage } from '../lib/clearStorage'
+import { getStorageInfo } from '../lib/getStorageInfo'
+import { removeStorage } from '../lib/removeStorage'
+
+const Taro = {
+  setStorage,
+  getStorage,
+  clearStorage,
+  getStorageInfo,
+  removeStorage,
+}
+
+// NativeModules.RNCAsyncStorage setup mock
+describe('storage', () => {
+  describe('setStorage', () => {
+    test('should set value into storage', async () => {
+      await Taro.clearStorage({})
+      const key = 'bar'
+      const data = 'foo'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      const res = await Taro.setStorage({
+        key,
+        data,
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'setStorage:ok'
+
+      expect.assertions(7)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual({ errMsg: expectMsg })
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectMsg })
+      expect(res.errMsg).toMatch(expectMsg)
+
+      const getData = await AsyncStorage.getItem(key) || ''
+      expect(JSON.parse(getData)).toBe(data)
+    })
+
+    test('should fail when error occur', async () => {
+      await Taro.clearStorage({})
+      const data = {}
+      const success = jest.fn().mockImplementation(() => {
+        throw new Error('setStorage:fail')
+      })
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      expect.assertions(4)
+      // @ts-ignore
+      return Taro.setStorage({
+        data,
+        success,
+        fail,
+        complete
+      }).catch(err => {
+        const expectErrMsg = err.errMsg
+        expect(fail.mock.calls.length).toBe(1)
+        expect(fail.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+        expect(complete.mock.calls.length).toBe(1)
+        expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+      })
+    })
+  })
+
+  describe('getStorage', () => {
+    test('should get value from storage by key', async () => {
+      await Taro.clearStorage({})
+      const key = 'bar'
+      const data = 'foo'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      await AsyncStorage.setItem(key, JSON.stringify(data))
+      const res = await Taro.getStorage({
+        key,
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'getStorage:ok'
+
+      expect.assertions(7)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual(res)
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual(res)
+      expect(res.errMsg).toMatch(expectMsg)
+      expect(res.data).toBe(data)
+    })
+  })
+
+  describe('removeStorage', () => {
+    test('能根据key删除Storage里的值', async () => {
+      await Taro.clearStorage({})
+      const key = 'bar'
+      const data = 'foo'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      await AsyncStorage.setItem(key, JSON.stringify(data))
+      const getData = await AsyncStorage.getItem(key) || ''
+
+      expect(JSON.parse(getData)).toBe(data)
+
+      const res = await Taro.removeStorage({
+        key,
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'removeStorage:ok'
+
+      expect.assertions(8)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual(res)
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual(res)
+      expect(res.errMsg).toMatch(expectMsg)
+      // @ts-ignore
+      expect(res.data).toBeUndefined()
+    })
+  })
+
+  describe('getStorageInfo', () => {
+    test('获得正确的StorageInfo', async () => {
+      await Taro.clearStorage({})
+      const key1 = 'bar'
+      const key2 = 'foo'
+      const data = 'data'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      await AsyncStorage.setItem(key1, JSON.stringify(data))
+      await AsyncStorage.setItem(key2, JSON.stringify(data))
+
+      const res = await Taro.getStorageInfo({
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'getStorageInfo:ok'
+
+      expect.assertions(9)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual(res)
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual(res)
+      expect(res.errMsg).toMatch(expectMsg)
+      // @ts-ignore
+      expect(res.keys).toEqual([key1, key2])
+      // @ts-ignore
+      expect(res.currentSize).toBe(+(12 / 1024).toFixed(2))
+      // @ts-ignore
+      expect(res.limitSize).toBe(Infinity)
+    })
+  })
+
+  describe('clearStorage', () => {
+    test('clearStorage能清楚所有的Storage', async () => {
+      await Taro.clearStorage({})
+      const key1 = 'bar'
+      const key2 = 'foo'
+      const data = 'data'
+
+      await AsyncStorage.setItem(key1, JSON.stringify(data))
+      await AsyncStorage.setItem(key2, JSON.stringify(data))
+
+      const getData1 = await AsyncStorage.getItem(key1) || ''
+      const getData2 = await AsyncStorage.getItem(key2) || ''
+
+      expect(JSON.parse(getData1)).toBe(data)
+      expect(JSON.parse(getData2)).toBe(data)
+
+      await Taro.clearStorage({})
+
+      const res = await AsyncStorage.getAllKeys()
+
+      expect.assertions(3)
+
+      expect(res).toEqual([])
+    })
+  })
+})

package/src/__tests__/system.test.ts

@@ -0,0 +1,69 @@
+import { getSystemInfo } from '../lib/getSystemInfo'
+import { getSystemInfoSync } from '../lib/getSystemInfoSync'
+
+const Taro = { getSystemInfo, getSystemInfoSync }
+
+describe('system', () => {
+  describe('getSystemInfoSync', () => {
+    test('能同步返回正确的系统信息', () => {
+      const expectRes = {
+        brand: expect.any(String),
+        model: expect.any(String),
+        pixelRatio: expect.any(Number),
+        safeArea: expect.any(Object),
+        screenWidth: expect.any(Number),
+        screenHeight: expect.any(Number),
+        windowWidth: expect.any(Number),
+        windowHeight: expect.any(Number),
+        statusBarHeight: expect.any(Number),
+        language: null,
+        version: expect.any(String),
+        system: expect.any(String),
+        platform: expect.any(String),
+        fontSizeSetting: expect.any(Number),
+        SDKVersion: null
+      }
+
+      const res = Taro.getSystemInfoSync()
+      expect(res).toEqual(expect.objectContaining(expectRes))
+    })
+  })
+
+  describe('getSystemInfo', () => {
+    test('能异步返回正确的系统信息', () => {
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+      const expectRes = {
+        brand: expect.any(String),
+        model: expect.any(String),
+        pixelRatio: expect.any(Number),
+        safeArea: expect.any(Object),
+        screenWidth: expect.any(Number),
+        screenHeight: expect.any(Number),
+        windowWidth: expect.any(Number),
+        windowHeight: expect.any(Number),
+        statusBarHeight: expect.any(Number),
+        language: null,
+        version: expect.any(String),
+        system: expect.any(String),
+        platform: expect.any(String),
+        fontSizeSetting: expect.any(Number),
+        SDKVersion: null
+      }
+
+      expect.assertions(4)
+
+      return Taro.getSystemInfo({
+        success,
+        fail,
+        complete
+      }).then((res) => {
+        expect(success.mock.calls.length).toBe(1)
+        expect(fail.mock.calls.length).toBe(0)
+        expect(complete.mock.calls.length).toBe(1)
+        expect(res).toEqual(expect.objectContaining(expectRes))
+      })
+    })
+  })
+})

package/src/__tests__/vibrate.test.ts

@@ -0,0 +1,27 @@
+import * as vibrate from '../lib/vibrate'
+
+const Taro = Object.assign({}, vibrate)
+
+describe('vibrate', () => {
+  describe('vibrateShort', () => {
+    test('能正常震动', () => {
+      const expectMsg = 'vibrateShort:ok'
+
+      expect.assertions(1)
+      return Taro.vibrateShort().then((res) => {
+        expect(res.errMsg).toMatch(expectMsg)
+      })
+    })
+  })
+
+  describe('vibrateLong', () => {
+    test('能正常震动', () => {
+      const expectMsg = 'vibrateLong:ok'
+
+      expect.assertions(1)
+      return Taro.vibrateLong().then((res) => {
+        expect(res.errMsg).toMatch(expectMsg)
+      })
+    })
+  })
+})