Skip to content

Commit 4487ce9

Browse files
jeffsmale90jeffsmale90
committed
Add additional test coverage
1 parent 05387b5 commit 4487ce9

7 files changed

Lines changed: 347 additions & 0 deletions

File tree

‎packages/7715-permission-types/test/permissions/caveats/erc20TokenAllowance.test.ts‎

Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -212,4 +212,63 @@ describe('createErc20TokenAllowanceCaveats()', () => {
212212
},
213213
]);
214214
});
215+
216+
it('rejects malformed numeric hex input', async () => {
217+
const invalidPermission = {
218+
...permission,
219+
data: {
220+
...permission.data,
221+
allowanceAmount: 'not-hex' as Hex,
222+
},
223+
};
224+
225+
await expect(
226+
createErc20TokenAllowanceCaveats({
227+
permission: invalidPermission,
228+
contracts,
229+
}),
230+
).rejects.toThrow();
231+
});
232+
233+
it('keeps valueLte caveat fixed at zero across varied inputs', async () => {
234+
const variedPermission: DeepRequired<Erc20TokenAllowancePermission> = {
235+
...permission,
236+
data: {
237+
...permission.data,
238+
tokenAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
239+
allowanceAmount:
240+
'0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
241+
startTime: 1,
242+
},
243+
};
244+
245+
const caveats = await createErc20TokenAllowanceCaveats({
246+
permission: variedPermission,
247+
contracts,
248+
});
249+
250+
expect(caveats[1]?.enforcer).toBe(contracts.valueLteEnforcer);
251+
expect(caveats[1]?.terms).toBe(ZERO_32_BYTES);
252+
});
253+
254+
it('encodes provided token address in allowance terms', async () => {
255+
const alternateTokenAddress = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
256+
const permissionWithAltToken = {
257+
...permission,
258+
data: {
259+
...permission.data,
260+
tokenAddress: alternateTokenAddress,
261+
},
262+
};
263+
264+
const caveats = await createErc20TokenAllowanceCaveats({
265+
permission: permissionWithAltToken,
266+
contracts,
267+
});
268+
269+
expect(caveats[0]?.enforcer).toBe(contracts.erc20PeriodicEnforcer);
270+
expect(
271+
caveats[0]?.terms.startsWith(`0x${alternateTokenAddress.slice(2)}`),
272+
).toBe(true);
273+
});
215274
});

‎packages/7715-permission-types/test/permissions/caveats/erc20TokenPeriodic.test.ts‎

Lines changed: 60 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -244,4 +244,64 @@ describe('createErc20TokenPeriodicCaveats()', () => {
244244
},
245245
]);
246246
});
247+
248+
it('rejects malformed numeric hex input', async () => {
249+
const invalidPermission = {
250+
...permission,
251+
data: {
252+
...permission.data,
253+
periodAmount: 'not-hex' as Hex,
254+
},
255+
};
256+
257+
await expect(
258+
createErc20TokenPeriodicCaveats({
259+
permission: invalidPermission,
260+
contracts,
261+
}),
262+
).rejects.toThrow();
263+
});
264+
265+
it('keeps valueLte caveat fixed at zero across varied inputs', async () => {
266+
const variedPermission: DeepRequired<Erc20TokenPeriodicPermission> = {
267+
...permission,
268+
data: {
269+
...permission.data,
270+
tokenAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
271+
periodAmount:
272+
'0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
273+
periodDuration: 1,
274+
startTime: 1,
275+
},
276+
};
277+
278+
const caveats = await createErc20TokenPeriodicCaveats({
279+
permission: variedPermission,
280+
contracts,
281+
});
282+
283+
expect(caveats[1]?.enforcer).toBe(contracts.valueLteEnforcer);
284+
expect(caveats[1]?.terms).toBe(ZERO_32_BYTES);
285+
});
286+
287+
it('encodes provided token address in periodic terms', async () => {
288+
const alternateTokenAddress = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
289+
const permissionWithAltToken = {
290+
...permission,
291+
data: {
292+
...permission.data,
293+
tokenAddress: alternateTokenAddress,
294+
},
295+
};
296+
297+
const caveats = await createErc20TokenPeriodicCaveats({
298+
permission: permissionWithAltToken,
299+
contracts,
300+
});
301+
302+
expect(caveats[0]?.enforcer).toBe(contracts.erc20PeriodicEnforcer);
303+
expect(
304+
caveats[0]?.terms.startsWith(`0x${alternateTokenAddress.slice(2)}`),
305+
).toBe(true);
306+
});
247307
});

‎packages/7715-permission-types/test/permissions/caveats/erc20TokenStream.test.ts‎

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -232,4 +232,65 @@ describe('createErc20TokenStreamCaveats()', () => {
232232
},
233233
]);
234234
});
235+
236+
it('rejects malformed numeric hex input', async () => {
237+
const invalidPermission = {
238+
...mockPermission,
239+
data: {
240+
...mockPermission.data,
241+
initialAmount: 'not-hex' as Hex,
242+
},
243+
};
244+
245+
await expect(
246+
createErc20TokenStreamCaveats({
247+
permission: invalidPermission,
248+
contracts,
249+
}),
250+
).rejects.toThrow();
251+
});
252+
253+
it('keeps valueLte caveat fixed at zero across varied inputs', async () => {
254+
const variedPermission: DeepRequired<Erc20TokenStreamPermission> = {
255+
...mockPermission,
256+
data: {
257+
...mockPermission.data,
258+
tokenAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
259+
initialAmount: '0x1',
260+
maxAmount:
261+
'0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
262+
amountPerSecond: '0x2',
263+
startTime: 1,
264+
},
265+
};
266+
267+
const caveats = await createErc20TokenStreamCaveats({
268+
permission: variedPermission,
269+
contracts,
270+
});
271+
272+
expect(caveats[1]?.enforcer).toBe(contracts.valueLteEnforcer);
273+
expect(caveats[1]?.terms).toBe(ZERO_32_BYTES);
274+
});
275+
276+
it('encodes provided token address in stream terms', async () => {
277+
const alternateTokenAddress = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
278+
const permission = {
279+
...mockPermission,
280+
data: {
281+
...mockPermission.data,
282+
tokenAddress: alternateTokenAddress,
283+
},
284+
};
285+
286+
const caveats = await createErc20TokenStreamCaveats({
287+
permission,
288+
contracts,
289+
});
290+
291+
expect(caveats[0]?.enforcer).toBe(contracts.erc20StreamingEnforcer);
292+
expect(
293+
caveats[0]?.terms.startsWith(`0x${alternateTokenAddress.slice(2)}`),
294+
).toBe(true);
295+
});
235296
});

‎packages/7715-permission-types/test/permissions/caveats/nativeTokenAllowance.test.ts‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -208,4 +208,41 @@ describe('createNativeTokenAllowanceCaveats()', () => {
208208
},
209209
]);
210210
});
211+
212+
it('rejects malformed numeric hex input', async () => {
213+
const invalidPermission = {
214+
...permission,
215+
data: {
216+
...permission.data,
217+
allowanceAmount: 'not-hex' as Hex,
218+
},
219+
};
220+
221+
await expect(
222+
createNativeTokenAllowanceCaveats({
223+
permission: invalidPermission,
224+
contracts,
225+
}),
226+
).rejects.toThrow();
227+
});
228+
229+
it('keeps exactCalldata caveat fixed across varied inputs', async () => {
230+
const variedPermission: DeepRequired<NativeTokenAllowancePermission> = {
231+
...permission,
232+
data: {
233+
...permission.data,
234+
allowanceAmount:
235+
'0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
236+
startTime: 1,
237+
},
238+
};
239+
240+
const caveats = await createNativeTokenAllowanceCaveats({
241+
permission: variedPermission,
242+
contracts,
243+
});
244+
245+
expect(caveats[1]?.enforcer).toBe(contracts.exactCalldataEnforcer);
246+
expect(caveats[1]?.terms).toBe('0x');
247+
});
211248
});

‎packages/7715-permission-types/test/permissions/caveats/nativeTokenPeriodic.test.ts‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -231,4 +231,42 @@ describe('createNativeTokenPeriodicCaveats()', () => {
231231
},
232232
]);
233233
});
234+
235+
it('rejects malformed numeric hex input', async () => {
236+
const invalidPermission = {
237+
...permission,
238+
data: {
239+
...permission.data,
240+
periodAmount: 'not-hex' as Hex,
241+
},
242+
};
243+
244+
await expect(
245+
createNativeTokenPeriodicCaveats({
246+
permission: invalidPermission,
247+
contracts,
248+
}),
249+
).rejects.toThrow();
250+
});
251+
252+
it('keeps exactCalldata caveat fixed across varied inputs', async () => {
253+
const variedPermission: DeepRequired<NativeTokenPeriodicPermission> = {
254+
...permission,
255+
data: {
256+
...permission.data,
257+
periodAmount:
258+
'0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
259+
periodDuration: 1,
260+
startTime: 1,
261+
},
262+
};
263+
264+
const caveats = await createNativeTokenPeriodicCaveats({
265+
permission: variedPermission,
266+
contracts,
267+
});
268+
269+
expect(caveats[1]?.enforcer).toBe(contracts.exactCalldataEnforcer);
270+
expect(caveats[1]?.terms).toBe('0x');
271+
});
234272
});

‎packages/7715-permission-types/test/permissions/caveats/nativeTokenStream.test.ts‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -213,4 +213,43 @@ describe('createNativeTokenStreamCaveats()', () => {
213213
},
214214
]);
215215
});
216+
217+
it('rejects malformed numeric hex input', async () => {
218+
const invalidPermission = {
219+
...permission,
220+
data: {
221+
...permission.data,
222+
initialAmount: 'not-hex' as Hex,
223+
},
224+
};
225+
226+
await expect(
227+
createNativeTokenStreamCaveats({
228+
permission: invalidPermission,
229+
contracts,
230+
}),
231+
).rejects.toThrow();
232+
});
233+
234+
it('keeps exactCalldata caveat fixed across varied inputs', async () => {
235+
const variedPermission: DeepRequired<NativeTokenStreamPermission> = {
236+
...permission,
237+
data: {
238+
...permission.data,
239+
initialAmount: '0x1',
240+
maxAmount:
241+
'0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
242+
amountPerSecond: '0x2',
243+
startTime: 1,
244+
},
245+
};
246+
247+
const caveats = await createNativeTokenStreamCaveats({
248+
permission: variedPermission,
249+
contracts,
250+
});
251+
252+
expect(caveats[1]?.enforcer).toBe(contracts.exactCalldataEnforcer);
253+
expect(caveats[1]?.terms).toBe('0x');
254+
});
216255
});

‎packages/7715-permission-types/test/permissions/caveats/tokenApprovalRevocation.test.ts‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -165,4 +165,57 @@ describe('createTokenApprovalRevocationCaveats()', () => {
165165
},
166166
]);
167167
});
168+
169+
it('creates single-flag approvalRevocation caveat', async () => {
170+
const singleFlagPermission: DeepRequired<TokenApprovalRevocationPermission> =
171+
{
172+
...permission,
173+
data: {
174+
...permission.data,
175+
erc20Approve: true,
176+
erc721Approve: false,
177+
erc721SetApprovalForAll: false,
178+
permit2Approve: false,
179+
permit2Lockdown: false,
180+
permit2InvalidateNonces: false,
181+
},
182+
};
183+
184+
const caveats = await createTokenApprovalRevocationCaveats({
185+
permission: singleFlagPermission,
186+
contracts,
187+
});
188+
189+
expect(caveats).toStrictEqual([
190+
{
191+
enforcer: contracts.approvalRevocationEnforcer,
192+
terms: '0x01',
193+
args: '0x',
194+
},
195+
]);
196+
});
197+
198+
it('rejects empty-mask approvalRevocation when all flags are false', async () => {
199+
const noFlagPermission: DeepRequired<TokenApprovalRevocationPermission> = {
200+
...permission,
201+
data: {
202+
...permission.data,
203+
erc20Approve: false,
204+
erc721Approve: false,
205+
erc721SetApprovalForAll: false,
206+
permit2Approve: false,
207+
permit2Lockdown: false,
208+
permit2InvalidateNonces: false,
209+
},
210+
};
211+
212+
await expect(
213+
createTokenApprovalRevocationCaveats({
214+
permission: noFlagPermission,
215+
contracts,
216+
}),
217+
).rejects.toThrow(
218+
'Invalid ApprovalRevocation terms: at least one revocation primitive must be enabled',
219+
);
220+
});
168221
});

0 commit comments

Comments
 (0)