@casual-simulation/aux-records 3.8.1 → 3.10.2

package/crud/CrudRecordsControllerTests.js

@@ -55,7 +55,13 @@ export async function setupTestContext(storeFactory, controllerFactory) {
  * @param createStoreItem The factory function that creates a test item.
  * @param configureEnvironment An optional function that can be used to configure the environment before the tests are run.
  */
-export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFactory, controllerFactory, createStoreItem, createInputItem, configureEnvironment, createOutputItem = createStoreItem, cleanup) {
+export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFactory, controllerFactory, createStoreItem, createInputItem, configureEnvironment, createOutputItem = createStoreItem, cleanup, allowedActions = [
+    'create',
+    'update',
+    'read',
+    'delete',
+    'list',
+]) {
     let context;
     let services;
     let store;
@@ -92,125 +98,394 @@ export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFa
             cleanup(context);
         }
     });
-    describe('recordItem()', () => {
-        describe('create', () => {
-            it('should store the item in the store', async () => {
-                const item = createInputItem({
+    if (allowedActions.includes('create') ||
+        allowedActions.includes('update')) {
+        describe('recordItem()', () => {
+            if (allowedActions.includes('create')) {
+                describe('create', () => {
+                    it('should store the item in the store', async () => {
+                        const item = createInputItem({
+                            address: 'address',
+                            markers: [PUBLIC_READ_MARKER],
+                        });
+                        const result = (await manager.recordItem({
+                            recordKeyOrRecordName: recordName,
+                            userId,
+                            item,
+                            instances: [],
+                        }));
+                        expect(result).toEqual({
+                            success: true,
+                            recordName: recordName,
+                            address: 'address',
+                        });
+                        await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
+                            address: 'address',
+                            markers: [PUBLIC_READ_MARKER],
+                        }));
+                    });
+                    it('should reject the request if given an invalid key', async () => {
+                        const result = (await manager.recordItem({
+                            recordKeyOrRecordName: 'not_a_key',
+                            userId,
+                            item: createInputItem({
+                                address: 'address',
+                                markers: [PUBLIC_READ_MARKER],
+                            }),
+                            instances: [],
+                        }));
+                        expect(result).toEqual({
+                            success: false,
+                            errorCode: 'record_not_found',
+                            errorMessage: expect.any(String),
+                        });
+                        await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toBeFalsy();
+                    });
+                    if (allowRecordKeys) {
+                        it('should support using a record key', async () => {
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: key,
+                                userId: otherUserId,
+                                item: createInputItem({
+                                    address: 'address',
+                                    markers: [PUBLIC_READ_MARKER],
+                                }),
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: true,
+                                recordName: recordName,
+                                address: 'address',
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toEqual({
+                                address: 'address',
+                                markers: [PUBLIC_READ_MARKER],
+                            });
+                        });
+                        it('should be able to use subjectless keys', async () => {
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: subjectlessKey,
+                                userId: otherUserId,
+                                item: createInputItem({
+                                    address: 'address',
+                                    markers: [PUBLIC_READ_MARKER],
+                                }),
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: true,
+                                recordName: recordName,
+                                address: 'address',
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toEqual({
+                                address: 'address',
+                                markers: [PUBLIC_READ_MARKER],
+                            });
+                        });
+                    }
+                    else {
+                        it('should reject the request if record keys are not allowed', async () => {
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: key,
+                                userId: otherUserId,
+                                item: createInputItem({
+                                    address: 'address',
+                                    markers: [PUBLIC_READ_MARKER],
+                                }),
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: false,
+                                errorCode: 'not_authorized',
+                                errorMessage: expect.any(String),
+                                reason: {
+                                    type: 'missing_permission',
+                                    recordName,
+                                    action: 'create',
+                                    resourceKind,
+                                    resourceId: 'address',
+                                    subjectType: 'user',
+                                    subjectId: otherUserId,
+                                },
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toBeFalsy();
+                        });
+                        it('should reject the request if subjectless keys are not allowed', async () => {
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: subjectlessKey,
+                                userId: otherUserId,
+                                item: createInputItem({
+                                    address: 'address',
+                                    markers: [PUBLIC_READ_MARKER],
+                                }),
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: false,
+                                errorCode: 'not_authorized',
+                                errorMessage: expect.any(String),
+                                reason: {
+                                    type: 'missing_permission',
+                                    recordName,
+                                    action: 'create',
+                                    resourceKind,
+                                    resourceId: 'address',
+                                    subjectType: 'user',
+                                    subjectId: otherUserId,
+                                },
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toBeFalsy();
+                        });
+                    }
+                });
+            }
+            if (allowedActions.includes('update')) {
+                describe('update', () => {
+                    beforeEach(async () => {
+                        await manager.recordItem({
+                            recordKeyOrRecordName: recordName,
+                            userId,
+                            item: createInputItem({
+                                address: 'address',
+                                markers: [PUBLIC_READ_MARKER],
+                            }),
+                            instances: [],
+                        });
+                    });
+                    it('should update the markers in the store', async () => {
+                        const item = createInputItem({
+                            address: 'address',
+                            markers: [PRIVATE_MARKER],
+                        });
+                        const result = (await manager.recordItem({
+                            recordKeyOrRecordName: recordName,
+                            userId,
+                            item,
+                            instances: [],
+                        }));
+                        expect(result).toEqual({
+                            success: true,
+                            recordName: recordName,
+                            address: 'address',
+                        });
+                        await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
+                            address: 'address',
+                            markers: [PRIVATE_MARKER],
+                        }));
+                    });
+                    it('should reject the request if given an invalid key', async () => {
+                        const item = createInputItem({
+                            address: 'address',
+                            markers: [PUBLIC_READ_MARKER],
+                        });
+                        const result = (await manager.recordItem({
+                            recordKeyOrRecordName: 'not_a_key',
+                            userId,
+                            item,
+                            instances: [],
+                        }));
+                        expect(result).toEqual({
+                            success: false,
+                            errorCode: 'record_not_found',
+                            errorMessage: expect.any(String),
+                        });
+                        await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
+                            address: 'address',
+                            markers: [PUBLIC_READ_MARKER],
+                        }));
+                    });
+                    if (allowRecordKeys) {
+                        it('should support using a record key', async () => {
+                            const item = createInputItem({
+                                address: 'address',
+                                markers: [PRIVATE_MARKER],
+                            });
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: key,
+                                userId,
+                                item,
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: true,
+                                recordName: recordName,
+                                address: 'address',
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
+                                address: 'address',
+                                markers: [PRIVATE_MARKER],
+                            }));
+                        });
+                        it('should be able to use subjectless keys', async () => {
+                            const item = createInputItem({
+                                address: 'address',
+                                markers: [PRIVATE_MARKER],
+                            });
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: subjectlessKey,
+                                userId,
+                                item,
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: true,
+                                recordName: recordName,
+                                address: 'address',
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
+                                address: 'address',
+                                markers: [PRIVATE_MARKER],
+                            }));
+                        });
+                    }
+                    else {
+                        it('should reject the request if record keys are not allowed', async () => {
+                            const item = createInputItem({
+                                address: 'address',
+                                markers: [PRIVATE_MARKER],
+                            });
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: key,
+                                userId: otherUserId,
+                                item,
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: false,
+                                errorCode: 'not_authorized',
+                                errorMessage: expect.any(String),
+                                reason: {
+                                    type: 'missing_permission',
+                                    recordName,
+                                    action: 'update',
+                                    resourceKind,
+                                    resourceId: 'address',
+                                    subjectType: 'user',
+                                    subjectId: otherUserId,
+                                },
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
+                                address: 'address',
+                                markers: [PUBLIC_READ_MARKER],
+                            }));
+                        });
+                        it('should reject the request if subjectless keys are not allowed', async () => {
+                            const item = createInputItem({
+                                address: 'address',
+                                markers: [PRIVATE_MARKER],
+                            });
+                            const result = (await manager.recordItem({
+                                recordKeyOrRecordName: subjectlessKey,
+                                userId: otherUserId,
+                                item,
+                                instances: [],
+                            }));
+                            expect(result).toEqual({
+                                success: false,
+                                errorCode: 'not_authorized',
+                                errorMessage: expect.any(String),
+                                reason: {
+                                    type: 'missing_permission',
+                                    recordName,
+                                    action: 'update',
+                                    resourceKind,
+                                    resourceId: 'address',
+                                    subjectType: 'user',
+                                    subjectId: otherUserId,
+                                },
+                            });
+                            await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
+                                address: 'address',
+                                markers: [PUBLIC_READ_MARKER],
+                            }));
+                        });
+                    }
+                });
+            }
+        });
+    }
+    if (allowedActions.includes('read')) {
+        describe('getItem()', () => {
+            beforeEach(async () => {
+                await itemsStore.createItem(recordName, createStoreItem({
                     address: 'address',
                     markers: [PUBLIC_READ_MARKER],
-                });
-                const result = (await manager.recordItem({
-                    recordKeyOrRecordName: recordName,
+                }));
+                await itemsStore.createItem(recordName, createStoreItem({
+                    address: 'address2',
+                    markers: [PRIVATE_MARKER],
+                }));
+                await itemsStore.createItem(recordName, createStoreItem({
+                    address: 'address3',
+                    markers: [PUBLIC_READ_MARKER],
+                }));
+            });
+            it('should return the item if the user has access', async () => {
+                const result = await manager.getItem({
+                    recordName: recordName,
                     userId,
-                    item,
+                    address: 'address2',
                     instances: [],
-                }));
-                expect(result).toEqual({
+                });
+                expect(result).toMatchObject({
                     success: true,
+                    item: createOutputItem({
+                        address: 'address2',
+                        markers: [PRIVATE_MARKER],
+                    }),
+                });
+            });
+            it('should return data_not_found if the item was not found', async () => {
+                const result = await manager.getItem({
                     recordName: recordName,
-                    address: 'address',
+                    userId,
+                    address: 'missing',
+                    instances: [],
+                });
+                expect(result).toEqual({
+                    success: false,
+                    errorCode: 'data_not_found',
+                    errorMessage: expect.any(String),
                 });
-                await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
-                    address: 'address',
-                    markers: [PUBLIC_READ_MARKER],
-                }));
             });
-            it('should reject the request if given an invalid key', async () => {
-                const result = (await manager.recordItem({
-                    recordKeyOrRecordName: 'not_a_key',
+            it('should return record_not_found if the record doesnt exist', async () => {
+                const result = await manager.getItem({
+                    recordName: 'missing',
                     userId,
-                    item: createInputItem({
-                        address: 'address',
-                        markers: [PUBLIC_READ_MARKER],
-                    }),
+                    address: 'address',
                     instances: [],
-                }));
+                });
                 expect(result).toEqual({
                     success: false,
                     errorCode: 'record_not_found',
                     errorMessage: expect.any(String),
                 });
-                await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toBeFalsy();
             });
             if (allowRecordKeys) {
-                it('should support using a record key', async () => {
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: key,
-                        userId: otherUserId,
-                        item: createInputItem({
-                            address: 'address',
-                            markers: [PUBLIC_READ_MARKER],
-                        }),
+                it('should be able to use a record key to access the item', async () => {
+                    const result = await manager.getItem({
+                        recordName: key,
+                        userId,
+                        address: 'address2',
                         instances: [],
-                    }));
-                    expect(result).toEqual({
-                        success: true,
-                        recordName: recordName,
-                        address: 'address',
                     });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toEqual({
-                        address: 'address',
-                        markers: [PUBLIC_READ_MARKER],
-                    });
-                });
-                it('should be able to use subjectless keys', async () => {
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: subjectlessKey,
-                        userId: otherUserId,
-                        item: createInputItem({
-                            address: 'address',
-                            markers: [PUBLIC_READ_MARKER],
-                        }),
-                        instances: [],
-                    }));
                     expect(result).toEqual({
                         success: true,
-                        recordName: recordName,
-                        address: 'address',
-                    });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toEqual({
-                        address: 'address',
-                        markers: [PUBLIC_READ_MARKER],
+                        item: createStoreItem({
+                            address: 'address2',
+                            markers: [PRIVATE_MARKER],
+                        }),
                     });
                 });
             }
             else {
-                it('should reject the request if record keys are not allowed', async () => {
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: key,
+                it('should return not_authorized if record keys are not allowed', async () => {
+                    const result = await manager.getItem({
+                        recordName: key,
                         userId: otherUserId,
-                        item: createInputItem({
-                            address: 'address',
-                            markers: [PUBLIC_READ_MARKER],
-                        }),
+                        address: 'address2',
                         instances: [],
-                    }));
-                    expect(result).toEqual({
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: expect.any(String),
-                        reason: {
-                            type: 'missing_permission',
-                            recordName,
-                            action: 'create',
-                            resourceKind,
-                            resourceId: 'address',
-                            subjectType: 'user',
-                            subjectId: otherUserId,
-                        },
                     });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toBeFalsy();
-                });
-                it('should reject the request if subjectless keys are not allowed', async () => {
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: subjectlessKey,
-                        userId: otherUserId,
-                        item: createInputItem({
-                            address: 'address',
-                            markers: [PUBLIC_READ_MARKER],
-                        }),
-                        instances: [],
-                    }));
                     expect(result).toEqual({
                         success: false,
                         errorCode: 'not_authorized',
@@ -218,151 +493,95 @@ export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFa
                         reason: {
                             type: 'missing_permission',
                             recordName,
-                            action: 'create',
+                            action: 'read',
                             resourceKind,
-                            resourceId: 'address',
+                            resourceId: 'address2',
                             subjectType: 'user',
                             subjectId: otherUserId,
                         },
                     });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toBeFalsy();
                 });
             }
         });
-        describe('update', () => {
+    }
+    if (allowedActions.includes('delete')) {
+        describe('eraseItem()', () => {
             beforeEach(async () => {
                 await manager.recordItem({
                     recordKeyOrRecordName: recordName,
-                    userId,
                     item: createInputItem({
                         address: 'address',
                         markers: [PUBLIC_READ_MARKER],
                     }),
+                    userId,
                     instances: [],
                 });
-            });
-            it('should update the markers in the store', async () => {
-                const item = createInputItem({
-                    address: 'address',
-                    markers: [PRIVATE_MARKER],
+                await manager.recordItem({
+                    recordKeyOrRecordName: recordName,
+                    item: createInputItem({
+                        address: 'address2',
+                        markers: [PUBLIC_READ_MARKER],
+                    }),
+                    userId,
+                    instances: [],
                 });
-                const result = (await manager.recordItem({
+                await manager.recordItem({
                     recordKeyOrRecordName: recordName,
+                    item: createInputItem({
+                        address: 'address3',
+                        markers: [PUBLIC_READ_MARKER],
+                    }),
                     userId,
-                    item,
                     instances: [],
-                }));
+                });
+            });
+            it('should erase the item if the user has access', async () => {
+                const result = await manager.eraseItem({
+                    recordName: recordName,
+                    userId,
+                    address: 'address2',
+                    instances: [],
+                });
                 expect(result).toEqual({
                     success: true,
-                    recordName: recordName,
-                    address: 'address',
                 });
-                await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
-                    address: 'address',
-                    markers: [PRIVATE_MARKER],
-                }));
+                await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeFalsy();
             });
-            it('should reject the request if given an invalid key', async () => {
-                const item = createInputItem({
-                    address: 'address',
-                    markers: [PUBLIC_READ_MARKER],
-                });
-                const result = (await manager.recordItem({
-                    recordKeyOrRecordName: 'not_a_key',
+            it('should return data_not_found if the item doesnt exist', async () => {
+                const result = await manager.eraseItem({
+                    recordName: recordName,
                     userId,
-                    item,
+                    address: 'missing',
                     instances: [],
-                }));
+                });
                 expect(result).toEqual({
                     success: false,
-                    errorCode: 'record_not_found',
-                    errorMessage: expect.any(String),
+                    errorCode: 'data_not_found',
+                    errorMessage: 'The item was not found.',
                 });
-                await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
-                    address: 'address',
-                    markers: [PUBLIC_READ_MARKER],
-                }));
             });
             if (allowRecordKeys) {
-                it('should support using a record key', async () => {
-                    const item = createInputItem({
-                        address: 'address',
-                        markers: [PRIVATE_MARKER],
-                    });
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: key,
-                        userId,
-                        item,
+                it('should erase the item if the record key has access', async () => {
+                    const result = await manager.eraseItem({
+                        recordName: key,
+                        userId: otherUserId,
+                        address: 'address2',
                         instances: [],
-                    }));
-                    expect(result).toEqual({
-                        success: true,
-                        recordName: recordName,
-                        address: 'address',
-                    });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(item);
-                });
-                it('should be able to use subjectless keys', async () => {
-                    const item = createInputItem({
-                        address: 'address',
-                        markers: [PRIVATE_MARKER],
                     });
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: subjectlessKey,
-                        userId,
-                        item,
-                        instances: [],
-                    }));
                     expect(result).toEqual({
                         success: true,
-                        recordName: recordName,
-                        address: 'address',
                     });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(item);
+                    await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeFalsy();
                 });
             }
             else {
-                it('should reject the request if record keys are not allowed', async () => {
-                    const item = createInputItem({
-                        address: 'address',
-                        markers: [PRIVATE_MARKER],
-                    });
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: key,
+                it('should return not_authorized if the controller doesnt allow record keys', async () => {
+                    const result = await manager.eraseItem({
+                        recordName: key,
                         userId: otherUserId,
-                        item,
+                        address: 'address2',
                         instances: [],
-                    }));
-                    expect(result).toEqual({
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: expect.any(String),
-                        reason: {
-                            type: 'missing_permission',
-                            recordName,
-                            action: 'update',
-                            resourceKind,
-                            resourceId: 'address',
-                            subjectType: 'user',
-                            subjectId: otherUserId,
-                        },
-                    });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
-                        address: 'address',
-                        markers: [PUBLIC_READ_MARKER],
-                    }));
-                });
-                it('should reject the request if subjectless keys are not allowed', async () => {
-                    const item = createInputItem({
-                        address: 'address',
-                        markers: [PRIVATE_MARKER],
                     });
-                    const result = (await manager.recordItem({
-                        recordKeyOrRecordName: subjectlessKey,
-                        userId: otherUserId,
-                        item,
-                        instances: [],
-                    }));
                     expect(result).toEqual({
                         success: false,
                         errorCode: 'not_authorized',
@@ -370,269 +589,117 @@ export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFa
                         reason: {
                             type: 'missing_permission',
                             recordName,
-                            action: 'update',
+                            action: 'delete',
                             resourceKind,
-                            resourceId: 'address',
+                            resourceId: 'address2',
                             subjectType: 'user',
                             subjectId: otherUserId,
                         },
                     });
-                    await expect(itemsStore.getItemByAddress(recordName, 'address')).resolves.toMatchObject(createStoreItem({
-                        address: 'address',
-                        markers: [PUBLIC_READ_MARKER],
-                    }));
+                    await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeTruthy();
                 });
             }
-        });
-    });
-    describe('getItem()', () => {
-        beforeEach(async () => {
-            await itemsStore.createItem(recordName, createStoreItem({
-                address: 'address',
-                markers: [PUBLIC_READ_MARKER],
-            }));
-            await itemsStore.createItem(recordName, createStoreItem({
-                address: 'address2',
-                markers: [PRIVATE_MARKER],
-            }));
-            await itemsStore.createItem(recordName, createStoreItem({
-                address: 'address3',
-                markers: [PUBLIC_READ_MARKER],
-            }));
-        });
-        it('should return the item if the user has access', async () => {
-            const result = await manager.getItem({
-                recordName: recordName,
-                userId,
-                address: 'address2',
-                instances: [],
-            });
-            expect(result).toMatchObject({
-                success: true,
-                item: createOutputItem({
-                    address: 'address2',
-                    markers: [PRIVATE_MARKER],
-                }),
-            });
-        });
-        it('should return data_not_found if the item was not found', async () => {
-            const result = await manager.getItem({
-                recordName: recordName,
-                userId,
-                address: 'missing',
-                instances: [],
-            });
-            expect(result).toEqual({
-                success: false,
-                errorCode: 'data_not_found',
-                errorMessage: expect.any(String),
-            });
-        });
-        it('should return record_not_found if the record doesnt exist', async () => {
-            const result = await manager.getItem({
-                recordName: 'missing',
-                userId,
-                address: 'address',
-                instances: [],
-            });
-            expect(result).toEqual({
-                success: false,
-                errorCode: 'record_not_found',
-                errorMessage: expect.any(String),
-            });
-        });
-        if (allowRecordKeys) {
-            it('should be able to use a record key to access the item', async () => {
-                const result = await manager.getItem({
-                    recordName: key,
+            it('should return record_not_found if the record doesnt exist', async () => {
+                const result = await manager.eraseItem({
+                    recordName: 'missing',
                     userId,
                     address: 'address2',
                     instances: [],
                 });
-                expect(result).toEqual({
-                    success: true,
-                    item: createStoreItem({
-                        address: 'address2',
-                        markers: [PRIVATE_MARKER],
-                    }),
-                });
-            });
-        }
-        else {
-            it('should return not_authorized if record keys are not allowed', async () => {
-                const result = await manager.getItem({
-                    recordName: key,
-                    userId: otherUserId,
-                    address: 'address2',
-                    instances: [],
-                });
                 expect(result).toEqual({
                     success: false,
-                    errorCode: 'not_authorized',
+                    errorCode: 'record_not_found',
                     errorMessage: expect.any(String),
-                    reason: {
-                        type: 'missing_permission',
-                        recordName,
-                        action: 'read',
-                        resourceKind,
-                        resourceId: 'address2',
-                        subjectType: 'user',
-                        subjectId: otherUserId,
-                    },
                 });
+                await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeTruthy();
             });
-        }
-    });
-    describe('eraseItem()', () => {
-        beforeEach(async () => {
-            await manager.recordItem({
-                recordKeyOrRecordName: recordName,
-                item: createInputItem({
-                    address: 'address',
-                    markers: [PUBLIC_READ_MARKER],
-                }),
-                userId,
-                instances: [],
-            });
-            await manager.recordItem({
-                recordKeyOrRecordName: recordName,
-                item: createInputItem({
-                    address: 'address2',
-                    markers: [PUBLIC_READ_MARKER],
-                }),
-                userId,
-                instances: [],
-            });
-            await manager.recordItem({
-                recordKeyOrRecordName: recordName,
-                item: createInputItem({
-                    address: 'address3',
-                    markers: [PUBLIC_READ_MARKER],
-                }),
-                userId,
-                instances: [],
-            });
-        });
-        it('should erase the item if the user has access', async () => {
-            const result = await manager.eraseItem({
-                recordName: recordName,
-                userId,
-                address: 'address2',
-                instances: [],
-            });
-            expect(result).toEqual({
-                success: true,
-            });
-            await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeFalsy();
         });
-        it('should return data_not_found if the item doesnt exist', async () => {
-            const result = await manager.eraseItem({
-                recordName: recordName,
-                userId,
-                address: 'missing',
-                instances: [],
-            });
-            expect(result).toEqual({
-                success: false,
-                errorCode: 'data_not_found',
-                errorMessage: 'The item was not found.',
+    }
+    if (allowedActions.includes('list')) {
+        describe('listItems()', () => {
+            let items;
+            beforeEach(async () => {
+                items = [];
+                for (let i = 0; i < 20; i++) {
+                    const item = createStoreItem({
+                        address: 'address' + i,
+                        markers: [PRIVATE_MARKER],
+                    });
+                    await itemsStore.createItem(recordName, item);
+                    items.push(createOutputItem({
+                        address: item.address,
+                        markers: item.markers,
+                    }));
+                }
             });
-        });
-        if (allowRecordKeys) {
-            it('should erase the item if the record key has access', async () => {
-                const result = await manager.eraseItem({
-                    recordName: key,
-                    userId: otherUserId,
-                    address: 'address2',
+            it('should return a list of items', async () => {
+                const result = (await manager.listItems({
+                    recordName: recordName,
+                    userId,
+                    startingAddress: null,
                     instances: [],
-                });
+                }));
                 expect(result).toEqual({
                     success: true,
+                    recordName: recordName,
+                    items: expect.any(Array),
+                    totalCount: 20,
                 });
-                await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeFalsy();
-            });
-        }
-        else {
-            it('should return not_authorized if the controller doesnt allow record keys', async () => {
-                const result = await manager.eraseItem({
-                    recordName: key,
-                    userId: otherUserId,
-                    address: 'address2',
-                    instances: [],
-                });
-                expect(result).toEqual({
-                    success: false,
-                    errorCode: 'not_authorized',
-                    errorMessage: expect.any(String),
-                    reason: {
-                        type: 'missing_permission',
-                        recordName,
-                        action: 'delete',
-                        resourceKind,
-                        resourceId: 'address2',
-                        subjectType: 'user',
-                        subjectId: otherUserId,
-                    },
-                });
-                await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeTruthy();
-            });
-        }
-        it('should return record_not_found if the record doesnt exist', async () => {
-            const result = await manager.eraseItem({
-                recordName: 'missing',
-                userId,
-                address: 'address2',
-                instances: [],
-            });
-            expect(result).toEqual({
-                success: false,
-                errorCode: 'record_not_found',
-                errorMessage: expect.any(String),
+                const expectedItems = items.slice(0, 10);
+                expect(result.items.length).toBe(expectedItems.length);
+                for (let i = 0; i < expectedItems.length; i++) {
+                    expect(result.items[i]).toMatchObject(expectedItems[i]);
+                }
             });
-            await expect(itemsStore.getItemByAddress(recordName, 'address2')).resolves.toBeTruthy();
-        });
-    });
-    describe('listItems()', () => {
-        let items;
-        beforeEach(async () => {
-            items = [];
-            for (let i = 0; i < 20; i++) {
-                const item = createStoreItem({
-                    address: 'address' + i,
-                    markers: [PRIVATE_MARKER],
+            if (allowRecordKeys) {
+                it('should be able to use a record key', async () => {
+                    const result = (await manager.listItems({
+                        recordName: key,
+                        userId: otherUserId,
+                        startingAddress: null,
+                        instances: [],
+                    }));
+                    expect(result).toEqual({
+                        success: true,
+                        recordName: recordName,
+                        items: expect.any(Array),
+                        totalCount: 20,
+                    });
+                    const expectedItems = items.slice(0, 10);
+                    expect(result.items.length).toBe(expectedItems.length);
+                    for (let i = 0; i < expectedItems.length; i++) {
+                        expect(result.items[i]).toMatchObject(expectedItems[i]);
+                    }
                 });
-                await itemsStore.createItem(recordName, item);
-                items.push(createOutputItem({
-                    address: item.address,
-                    markers: item.markers,
-                }));
             }
-        });
-        it('should return a list of items', async () => {
-            const result = (await manager.listItems({
-                recordName: recordName,
-                userId,
-                startingAddress: null,
-                instances: [],
-            }));
-            expect(result).toEqual({
-                success: true,
-                recordName: recordName,
-                items: expect.any(Array),
-                totalCount: 20,
-            });
-            const expectedItems = items.slice(0, 10);
-            expect(result.items.length).toBe(expectedItems.length);
-            for (let i = 0; i < expectedItems.length; i++) {
-                expect(result.items[i]).toMatchObject(expectedItems[i]);
+            else {
+                it('should return not_authorized if record keys are not allowed', async () => {
+                    const result = await manager.listItems({
+                        recordName: key,
+                        userId: otherUserId,
+                        startingAddress: null,
+                        instances: [],
+                    });
+                    expect(result).toEqual({
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: expect.any(String),
+                        reason: {
+                            type: 'missing_permission',
+                            recordName,
+                            action: 'list',
+                            resourceKind,
+                            subjectType: 'user',
+                            subjectId: otherUserId,
+                        },
+                    });
+                });
             }
-        });
-        if (allowRecordKeys) {
-            it('should be able to use a record key', async () => {
+            it('should return items after the given starting address', async () => {
                 const result = (await manager.listItems({
-                    recordName: key,
-                    userId: otherUserId,
-                    startingAddress: null,
+                    recordName: recordName,
+                    userId,
+                    startingAddress: 'address3',
                     instances: [],
                 }));
                 expect(result).toEqual({
@@ -641,19 +708,17 @@ export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFa
                     items: expect.any(Array),
                     totalCount: 20,
                 });
-                const expectedItems = items.slice(0, 10);
+                const expectedItems = items.slice(4, 10);
                 expect(result.items.length).toBe(expectedItems.length);
                 for (let i = 0; i < expectedItems.length; i++) {
                     expect(result.items[i]).toMatchObject(expectedItems[i]);
                 }
             });
-        }
-        else {
-            it('should return not_authorized if record keys are not allowed', async () => {
+            it('should return not_authorized if the user does not have access to the account marker', async () => {
                 const result = await manager.listItems({
-                    recordName: key,
+                    recordName: recordName,
                     userId: otherUserId,
-                    startingAddress: null,
+                    startingAddress: 'address3',
                     instances: [],
                 });
                 expect(result).toEqual({
@@ -661,125 +726,39 @@ export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFa
                     errorCode: 'not_authorized',
                     errorMessage: expect.any(String),
                     reason: {
-                        type: 'missing_permission',
-                        recordName,
                         action: 'list',
-                        resourceKind,
-                        subjectType: 'user',
+                        recordName: recordName,
+                        resourceId: undefined,
+                        resourceKind: resourceKind,
                         subjectId: otherUserId,
+                        subjectType: 'user',
+                        type: 'missing_permission',
                     },
                 });
             });
-        }
-        it('should return items after the given starting address', async () => {
-            const result = (await manager.listItems({
-                recordName: recordName,
-                userId,
-                startingAddress: 'address3',
-                instances: [],
-            }));
-            expect(result).toEqual({
-                success: true,
-                recordName: recordName,
-                items: expect.any(Array),
-                totalCount: 20,
-            });
-            const expectedItems = items.slice(4, 10);
-            expect(result.items.length).toBe(expectedItems.length);
-            for (let i = 0; i < expectedItems.length; i++) {
-                expect(result.items[i]).toMatchObject(expectedItems[i]);
-            }
-        });
-        it('should return not_authorized if the user does not have access to the account marker', async () => {
-            const result = await manager.listItems({
-                recordName: recordName,
-                userId: otherUserId,
-                startingAddress: 'address3',
-                instances: [],
-            });
-            expect(result).toEqual({
-                success: false,
-                errorCode: 'not_authorized',
-                errorMessage: expect.any(String),
-                reason: {
-                    action: 'list',
-                    recordName: recordName,
-                    resourceId: undefined,
-                    resourceKind: resourceKind,
-                    subjectId: otherUserId,
-                    subjectType: 'user',
-                    type: 'missing_permission',
-                },
-            });
-        });
-    });
-    describe('listItemsByMarker()', () => {
-        let items;
-        beforeEach(async () => {
-            items = [];
-            for (let i = 0; i < 40; i++) {
-                const item = createStoreItem({
-                    address: 'address' + i,
-                    markers: [
-                        i % 2 === 0 ? PRIVATE_MARKER : PUBLIC_READ_MARKER,
-                    ],
-                });
-                await itemsStore.createItem(recordName, item);
-                items.push(createOutputItem({
-                    address: item.address,
-                    markers: item.markers,
-                }));
-            }
-        });
-        it('should return a list of items that have the given marker', async () => {
-            const result = (await manager.listItemsByMarker({
-                recordName: recordName,
-                userId,
-                marker: PRIVATE_MARKER,
-                startingAddress: null,
-                instances: [],
-            }));
-            expect(result).toEqual({
-                success: true,
-                recordName: recordName,
-                items: expect.any(Array),
-                totalCount: 20,
-            });
-            const expectedItems = items
-                .filter((i) => i.markers.indexOf(PRIVATE_MARKER) >= 0)
-                .slice(0, 10);
-            expect(result.items.length).toBe(expectedItems.length);
-            for (let i = 0; i < expectedItems.length; i++) {
-                expect(result.items[i]).toMatchObject(expectedItems[i]);
-            }
         });
-        it('should return a list of items that are after the starting address', async () => {
-            const result = (await manager.listItemsByMarker({
-                recordName: recordName,
-                userId,
-                marker: PRIVATE_MARKER,
-                startingAddress: 'address1',
-                instances: [],
-            }));
-            expect(result).toEqual({
-                success: true,
-                recordName: recordName,
-                items: expect.any(Array),
-                totalCount: 20,
+        describe('listItemsByMarker()', () => {
+            let items;
+            beforeEach(async () => {
+                items = [];
+                for (let i = 0; i < 40; i++) {
+                    const item = createStoreItem({
+                        address: 'address' + i,
+                        markers: [
+                            i % 2 === 0 ? PRIVATE_MARKER : PUBLIC_READ_MARKER,
+                        ],
+                    });
+                    await itemsStore.createItem(recordName, item);
+                    items.push(createOutputItem({
+                        address: item.address,
+                        markers: item.markers,
+                    }));
+                }
             });
-            const expectedItems = items
-                .filter((i) => i.markers.indexOf(PRIVATE_MARKER) >= 0)
-                .slice(1, 11);
-            expect(result.items.length).toBe(expectedItems.length);
-            for (let i = 0; i < expectedItems.length; i++) {
-                expect(result.items[i]).toMatchObject(expectedItems[i]);
-            }
-        });
-        if (allowRecordKeys) {
-            it('should be able to use a record key', async () => {
+            it('should return a list of items that have the given marker', async () => {
                 const result = (await manager.listItemsByMarker({
-                    recordName: key,
-                    userId: otherUserId,
+                    recordName: recordName,
+                    userId,
                     marker: PRIVATE_MARKER,
                     startingAddress: null,
                     instances: [],
@@ -798,54 +777,100 @@ export function testCrudRecordsController(allowRecordKeys, resourceKind, storeFa
                     expect(result.items[i]).toMatchObject(expectedItems[i]);
                 }
             });
-        }
-        else {
-            it('should return not_authorized if record keys are not allowed', async () => {
+            it('should return a list of items that are after the starting address', async () => {
                 const result = (await manager.listItemsByMarker({
-                    recordName: key,
+                    recordName: recordName,
+                    userId,
+                    marker: PRIVATE_MARKER,
+                    startingAddress: 'address1',
+                    instances: [],
+                }));
+                expect(result).toEqual({
+                    success: true,
+                    recordName: recordName,
+                    items: expect.any(Array),
+                    totalCount: 20,
+                });
+                const expectedItems = items
+                    .filter((i) => i.markers.indexOf(PRIVATE_MARKER) >= 0)
+                    .slice(1, 11);
+                expect(result.items.length).toBe(expectedItems.length);
+                for (let i = 0; i < expectedItems.length; i++) {
+                    expect(result.items[i]).toMatchObject(expectedItems[i]);
+                }
+            });
+            if (allowRecordKeys) {
+                it('should be able to use a record key', async () => {
+                    const result = (await manager.listItemsByMarker({
+                        recordName: key,
+                        userId: otherUserId,
+                        marker: PRIVATE_MARKER,
+                        startingAddress: null,
+                        instances: [],
+                    }));
+                    expect(result).toEqual({
+                        success: true,
+                        recordName: recordName,
+                        items: expect.any(Array),
+                        totalCount: 20,
+                    });
+                    const expectedItems = items
+                        .filter((i) => i.markers.indexOf(PRIVATE_MARKER) >= 0)
+                        .slice(0, 10);
+                    expect(result.items.length).toBe(expectedItems.length);
+                    for (let i = 0; i < expectedItems.length; i++) {
+                        expect(result.items[i]).toMatchObject(expectedItems[i]);
+                    }
+                });
+            }
+            else {
+                it('should return not_authorized if record keys are not allowed', async () => {
+                    const result = (await manager.listItemsByMarker({
+                        recordName: key,
+                        userId: otherUserId,
+                        marker: PRIVATE_MARKER,
+                        startingAddress: null,
+                        instances: [],
+                    }));
+                    expect(result).toEqual({
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: expect.any(String),
+                        reason: {
+                            type: 'missing_permission',
+                            recordName,
+                            action: 'list',
+                            resourceKind,
+                            subjectType: 'user',
+                            subjectId: otherUserId,
+                        },
+                    });
+                });
+            }
+            it('should return not_authorized if the user does not have access to the marker', async () => {
+                const result = await manager.listItemsByMarker({
+                    recordName: recordName,
                     userId: otherUserId,
                     marker: PRIVATE_MARKER,
                     startingAddress: null,
                     instances: [],
-                }));
+                });
                 expect(result).toEqual({
                     success: false,
                     errorCode: 'not_authorized',
                     errorMessage: expect.any(String),
                     reason: {
-                        type: 'missing_permission',
-                        recordName,
                         action: 'list',
-                        resourceKind,
-                        subjectType: 'user',
+                        recordName: recordName,
+                        resourceId: undefined,
+                        resourceKind: resourceKind,
                         subjectId: otherUserId,
+                        subjectType: 'user',
+                        type: 'missing_permission',
                     },
                 });
             });
-        }
-        it('should return not_authorized if the user does not have access to the marker', async () => {
-            const result = await manager.listItemsByMarker({
-                recordName: recordName,
-                userId: otherUserId,
-                marker: PRIVATE_MARKER,
-                startingAddress: null,
-                instances: [],
-            });
-            expect(result).toEqual({
-                success: false,
-                errorCode: 'not_authorized',
-                errorMessage: expect.any(String),
-                reason: {
-                    action: 'list',
-                    recordName: recordName,
-                    resourceId: undefined,
-                    resourceKind: resourceKind,
-                    subjectId: otherUserId,
-                    subjectType: 'user',
-                    type: 'missing_permission',
-                },
-            });
         });
-    });
+    }
 }
 //# sourceMappingURL=CrudRecordsControllerTests.js.map