Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | 11x 11x 65x 17x 48x 11x 35x 35x 35x 35x 35x 35x 35x 35x 35x 35x 35x 11x 26x 26x 26x 26x 26x 11x 1x 1x 1x 1x 1x 1x 1x 11x 3x 3x 3x 3x 3x 3x 11x 2x 2x 2x 2x 2x 2x 2x 11x 2x 2x 2x 1x 1x 1x | /*
* Flow JS Testing
*
* Copyright 2020-2021 Dapper Labs, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import {getPaths, getStorageValue} from "./storage"
import {getValueByKey, parsePath} from "./utils"
const {expect} = global
/**
* Return Promise from passed interaction
* @param {function | Promise} ix - Promise or function to wrap
* @returns Promise<*>
* */
export const promise = async ix => {
if (typeof ix === "function") {
return await ix()
}
return await ix
}
/**
* Ensure transaction did not throw and sealed.
* @param {function | Promise} ix - Promise or function to wrap
* @returns Promise<*> - transaction result
* */
export const shallPass = async ix => {
const wrappedInteraction = promise(ix)
const response = await wrappedInteraction
const [result, error] = response
Iif (error) {
throw error
}
let resolvedStatus
let resolvedErrorMessage
Iif (Array.isArray(result)) {
const {status, errorMessage} = result
resolvedStatus = status
resolvedErrorMessage = errorMessage
} else {
const {status, errorMessage} = result
resolvedStatus = status
resolvedErrorMessage = errorMessage
}
await expect(resolvedStatus).toBe(4)
await expect(resolvedErrorMessage).toBe("")
return response
}
/**
* Ensure interaction did not throw and return result of it
* @param {function | Promise} ix - Promise or function to wrap
* @returns Promise<*> - result of interaction
* */
export const shallResolve = async ix => {
const wrappedInteraction = promise(ix)
const response = await wrappedInteraction
const [, error] = response
expect(error).toBe(null)
return response
}
/**
* Ensure interaction throws an error.
* @param {function | Promise} ix - Promise or function to wrap
* @param {string | RegExp} [message] - Expected error message provided as either a string equality or regular expression
* @returns Promise<*> - result of interaction
* */
export const shallRevert = async (ix, message) => {
const wrappedInteraction = promise(ix)
const response = await wrappedInteraction
const [result, error] = response
await expect(result).toBe(null)
Iif (message) {
const errorMessage = error
.toString()
.match(/^error: (panic)|(assertion failed): ([^\r\n]*)$/m)
?.at(3)
if (message instanceof RegExp) {
await expect(errorMessage).toMatch(message)
} else {
await expect(errorMessage).toBe(message)
}
} else {
await expect(error).not.toBe(null)
}
return response
}
/**
* Ensure interaction throws an error.
* @param {function | Promise} ix - Promise or function to wrap
* @returns Promise<*> - result of interaction
* */
export const shallThrow = async ix => {
const wrappedInteraction = promise(ix)
const response = await wrappedInteraction
const [result, error] = response
await expect(result).toBe(null)
await expect(error).not.toBe(null)
return response
}
/**
* Asserts that the given account has the given path enabled.
*
* @async
* @param {string} account - The address or name of the account to check for the path.
* @param {string} path - The path to check for.
* @returns {Promise<void>} A Promise that resolves when the assertion is complete, or rejects with an error if the assertion fails.
*/
export const shallHavePath = async (account, path) => {
let parsedPath
expect(() => {
parsedPath = parsePath(path)
}).not.toThrowError()
const {domain, slot} = parsedPath
const paths = await getPaths(account)
const key = `${domain}Paths`
const hasPathEnabled = paths[key].has(slot)
await expect(hasPathEnabled).toBe(true)
}
/**
* Asserts that the given account has the expected storage value at the given path.
*
* @async
* @param {string} account - The address or name of the account to check for the storage value.
* @param {{pathName: string, key?: string, expect: any}} params - An object containing the path name, optional key, and expected value.
* @returns {Promise<void>} A Promise that resolves when the assertion is complete, or rejects with an error if the assertion fails.
*/
export const shallHaveStorageValue = async (account, params) => {
const {pathName, key} = params
const storageValue = await getStorageValue(account, pathName)
if (key) {
const actualValue = getValueByKey(key, storageValue)
expect(actualValue).toBe(params.expect)
} else {
expect(storageValue).toBe(params.expect)
}
}
|