@flusys/nestjs-form-builder 7.1.0 → 8.0.0-beta.1

package/fesm/services/form-result.service.spec.js

@@ -1,778 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { FormResult } from '../entities';
-import { FormAccessType } from '../enums/form-access-type.enum';
-import * as permissionUtils from '../utils/permission.utils';
-import { FormResultService } from './form-result.service';
-import { FormBuilderConfigService } from './form-builder-config.service';
-import { FormBuilderDataSourceProvider } from './form-builder-datasource.provider';
-jest.mock('../utils/permission.utils', ()=>({
-        validateUserPermissions: jest.fn()
-    }));
-function buildForm(overrides = {}) {
-    return {
-        id: 'form-uuid-1',
-        name: 'Customer Survey',
-        description: null,
-        slug: 'customer-survey',
-        schema: {
-            sections: [],
-            settings: {}
-        },
-        schemaVersion: 1,
-        accessType: FormAccessType.AUTHENTICATED,
-        actionGroups: null,
-        tags: null,
-        isActive: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-function buildFormResult(overrides = {}) {
-    return {
-        id: 'result-uuid-1',
-        formId: 'form-uuid-1',
-        schemaVersionSnapshot: {
-            sections: []
-        },
-        schemaVersion: 1,
-        data: {
-            field1: 'value1'
-        },
-        submittedById: 'user-uuid-1',
-        submittedAt: new Date(),
-        isDraft: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('FormResultService', ()=>{
-    let service;
-    let mockResultRepo;
-    let mockFormRepo;
-    let mockFormBuilderConfig;
-    const mockUtilsService = {
-        clearCache: jest.fn(),
-        getCacheKey: jest.fn().mockReturnValue('cache-key'),
-        trackCacheKey: jest.fn()
-    };
-    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
-    beforeEach(()=>{
-        mockUtilsService.clearCache.mockClear();
-    });
-    async function buildService(companyFeatureEnabled = false) {
-        mockResultRepo = createMockRepository();
-        mockFormRepo = createMockRepository();
-        // `softRemove` isn't part of the shared repository mock's default method list — add it here.
-        mockResultRepo.softRemove = jest.fn();
-        // Extend the shared query-builder mock with the extra chain methods this service relies on
-        // (`innerJoin` for the company scoping join).
-        mockResultRepo.createQueryBuilder.mockReturnValue({
-            ...createMockQueryBuilder(),
-            innerJoin: jest.fn().mockReturnThis()
-        });
-        const mockDataSourceProvider = {
-            getRepository: jest.fn((entity)=>{
-                if (entity === FormResult) return Promise.resolve(mockResultRepo);
-                return Promise.resolve(mockFormRepo);
-            }),
-            getDataSource: jest.fn()
-        };
-        mockFormBuilderConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(companyFeatureEnabled)
-        };
-        const module = await Test.createTestingModule({
-            providers: [
-                FormResultService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {}
-                },
-                {
-                    provide: UtilsService,
-                    useValue: mockUtilsService
-                },
-                {
-                    provide: FormBuilderConfigService,
-                    useValue: mockFormBuilderConfig
-                },
-                {
-                    provide: FormBuilderDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(FormResultService);
-    }
-    afterEach(()=>{
-        jest.clearAllMocks();
-    });
-    // ==========================================================================
-    // getSelectQuery
-    // ==========================================================================
-    describe('getSelectQuery', ()=>{
-        it('applies the default field list, prefixed with the entity name', async ()=>{
-            await buildService(false);
-            const query = {
-                select: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, buildMockUser(), undefined);
-            expect(query.select).toHaveBeenCalledWith(expect.arrayContaining([
-                'form_result.id',
-                'form_result.formId',
-                'form_result.data',
-                'form_result.isDraft'
-            ]));
-        });
-        it('respects a custom select list', async ()=>{
-            await buildService(false);
-            const query = {
-                select: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, buildMockUser(), [
-                'id',
-                'data'
-            ]);
-            expect(query.select).toHaveBeenCalledWith([
-                'form_result.id',
-                'form_result.data'
-            ]);
-        });
-    });
-    // ==========================================================================
-    // getExtraManipulateQuery / applyCompanyFilterToQuery
-    // ==========================================================================
-    describe('getExtraManipulateQuery', ()=>{
-        it('joins the form table and filters by company when company feature is enabled', async ()=>{
-            await buildService(true);
-            const query = {
-                innerJoin: jest.fn().mockReturnThis(),
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, buildMockUser({
-                companyId: 'company-1'
-            }));
-            expect(query.innerJoin).toHaveBeenCalledWith('form', 'f', 'f.id = form_result.formId');
-            expect(query.andWhere).toHaveBeenCalledWith('f.company_id = :companyId', {
-                companyId: 'company-1'
-            });
-        });
-        it('does not join when company feature is disabled', async ()=>{
-            await buildService(false);
-            const query = {
-                innerJoin: jest.fn().mockReturnThis(),
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, buildMockUser({
-                companyId: 'company-1'
-            }));
-            expect(query.innerJoin).not.toHaveBeenCalled();
-        });
-        it('does not join when the user has no companyId', async ()=>{
-            await buildService(true);
-            const query = {
-                innerJoin: jest.fn().mockReturnThis(),
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, buildMockUser({
-                companyId: undefined
-            }));
-            expect(query.innerJoin).not.toHaveBeenCalled();
-        });
-        it('does not join when there is no user (public queries)', async ()=>{
-            await buildService(true);
-            const query = {
-                innerJoin: jest.fn().mockReturnThis(),
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, null);
-            expect(query.innerJoin).not.toHaveBeenCalled();
-        });
-    });
-    // ==========================================================================
-    // convertEntityToResponseDto
-    // ==========================================================================
-    describe('convertEntityToResponseDto', ()=>{
-        it('maps entity fields to the response shape', async ()=>{
-            await buildService(false);
-            const entity = buildFormResult();
-            const dto = service.convertEntityToResponseDto(entity, false);
-            expect(dto).toMatchObject({
-                id: entity.id,
-                formId: entity.formId,
-                data: entity.data,
-                isDraft: false
-            });
-        });
-    });
-    // ==========================================================================
-    // submitForm
-    // ==========================================================================
-    describe('submitForm', ()=>{
-        it('throws NotFoundException when the form does not exist or is inactive', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(null);
-            await expect(service.submitForm({
-                formId: 'missing',
-                data: {}
-            }, buildMockUser(), false)).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'form.not.found'
-                })
-            });
-        });
-        it('rejects a public submission when the form is not marked PUBLIC', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.AUTHENTICATED
-            }));
-            await expect(service.submitForm({
-                formId: 'form-uuid-1',
-                data: {}
-            }, null, true)).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'form.not.public'
-                })
-            });
-        });
-        it('allows a public submission to a PUBLIC form without a user', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.PUBLIC
-            }));
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                submittedById: null
-            }));
-            const result = await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'x'
-                }
-            }, null, true);
-            expect(mockResultRepo.findOne).not.toHaveBeenCalled();
-            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                formId: 'form-uuid-1',
-                submittedById: null,
-                isDraft: false
-            }));
-            expect(result.formId).toBe('form-uuid-1');
-        });
-        it('requires authentication for a non-public form submitted through the authenticated flow', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.AUTHENTICATED
-            }));
-            await expect(service.submitForm({
-                formId: 'form-uuid-1',
-                data: {}
-            }, null, false)).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'form.auth.required'
-                })
-            });
-        });
-        it('allows submission to an ACTION_GROUP form when the user has the required permission', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.ACTION_GROUP,
-                actionGroups: [
-                    'hr.submit'
-                ]
-            }));
-            permissionUtils.validateUserPermissions.mockResolvedValue(true);
-            mockResultRepo.findOne.mockResolvedValue(null);
-            mockResultRepo.save.mockResolvedValue(buildFormResult());
-            const result = await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {}
-            }, buildMockUser(), false);
-            expect(result.formId).toBe('form-uuid-1');
-        });
-        it('rejects submission to an ACTION_GROUP form when the user lacks the required permission', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.ACTION_GROUP,
-                actionGroups: [
-                    'hr.submit'
-                ]
-            }));
-            permissionUtils.validateUserPermissions.mockResolvedValue(false);
-            await expect(service.submitForm({
-                formId: 'form-uuid-1',
-                data: {}
-            }, buildMockUser(), false)).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'form.access.denied'
-                })
-            });
-        });
-        it('rejects submission for an unrecognized (non-AUTHENTICATED) access type', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: 'weird'
-            }));
-            await expect(service.submitForm({
-                formId: 'form-uuid-1',
-                data: {}
-            }, buildMockUser(), false)).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'form.invalid.access.type'
-                })
-            });
-        });
-        it('saves a new final submission with a schema snapshot and computed fields', async ()=>{
-            await buildService(false);
-            const form = buildForm({
-                schema: {
-                    settings: {
-                        computedFields: [
-                            {
-                                id: 'cf-1',
-                                name: 'Total',
-                                key: 'total',
-                                valueType: 'number',
-                                rules: [
-                                    {
-                                        id: 'r1',
-                                        computation: {
-                                            type: 'direct',
-                                            config: {
-                                                type: 'direct',
-                                                value: 99
-                                            }
-                                        }
-                                    }
-                                ]
-                            }
-                        ]
-                    }
-                }
-            });
-            mockFormRepo.findOne.mockResolvedValue(form);
-            mockResultRepo.findOne.mockResolvedValue(null);
-            mockResultRepo.save.mockResolvedValue(buildFormResult());
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'x'
-                }
-            }, buildMockUser(), false);
-            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                schemaVersionSnapshot: form.schema,
-                schemaVersion: form.schemaVersion,
-                data: {
-                    field1: 'x',
-                    _computed: {
-                        total: 99
-                    }
-                },
-                isDraft: false
-            }));
-        });
-        it('invalidates the result list cache and the new entry after a submission', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm());
-            mockResultRepo.findOne.mockResolvedValue(null);
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                id: 'result-1'
-            }));
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'x'
-                }
-            }, buildMockUser(), false);
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('form_result', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('form_result', expect.anything(), 'result-1');
-        });
-        it('invalidates the soft-removed draft as well when a draft is finalized into a new record', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm());
-            mockResultRepo.findOne.mockResolvedValue(buildFormResult({
-                id: 'draft-1',
-                isDraft: true
-            }));
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                id: 'result-2'
-            }));
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'x'
-                },
-                isDraft: false
-            }, buildMockUser(), false);
-            expect(mockResultRepo.softRemove).toHaveBeenCalled();
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('form_result', expect.anything(), 'draft-1');
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('form_result', expect.anything(), 'result-2');
-        });
-        it('does not compute fields when saving as a draft', async ()=>{
-            await buildService(false);
-            const form = buildForm({
-                schema: {
-                    settings: {
-                        computedFields: [
-                            {
-                                id: 'cf-1',
-                                name: 'Total',
-                                key: 'total',
-                                valueType: 'number',
-                                rules: [
-                                    {
-                                        id: 'r1',
-                                        computation: {
-                                            type: 'direct',
-                                            config: {
-                                                type: 'direct',
-                                                value: 99
-                                            }
-                                        }
-                                    }
-                                ]
-                            }
-                        ]
-                    }
-                }
-            });
-            mockFormRepo.findOne.mockResolvedValue(form);
-            mockResultRepo.findOne.mockResolvedValue(null);
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                isDraft: true
-            }));
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'x'
-                },
-                isDraft: true
-            }, buildMockUser(), false);
-            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                data: {
-                    field1: 'x'
-                },
-                isDraft: true
-            }));
-        });
-        it('replaces an existing draft with the final submission (soft-removes the draft, inserts a new record)', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm());
-            const existingDraft = buildFormResult({
-                id: 'draft-1',
-                isDraft: true
-            });
-            mockResultRepo.findOne.mockResolvedValue(existingDraft);
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                id: 'final-1',
-                isDraft: false
-            }));
-            const result = await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'y'
-                }
-            }, buildMockUser(), false);
-            expect(mockResultRepo.softRemove).toHaveBeenCalledWith(existingDraft);
-            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                formId: 'form-uuid-1',
-                isDraft: false
-            }));
-            expect(result.id).toBe('final-1');
-        });
-        it('updates an existing draft in place when re-submitting as a draft', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm());
-            const existingDraft = buildFormResult({
-                id: 'draft-1',
-                isDraft: true
-            });
-            mockResultRepo.findOne.mockResolvedValue(existingDraft);
-            mockResultRepo.save.mockResolvedValue({
-                ...existingDraft,
-                data: {
-                    field1: 'z'
-                }
-            });
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'z'
-                },
-                isDraft: true
-            }, buildMockUser(), false);
-            expect(mockResultRepo.softRemove).not.toHaveBeenCalled();
-            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                id: 'draft-1',
-                data: {
-                    field1: 'z'
-                }
-            }));
-        });
-    });
-    // ==========================================================================
-    // getMyDraft
-    // ==========================================================================
-    describe('getMyDraft', ()=>{
-        it('returns the most recent draft for the user', async ()=>{
-            await buildService(false);
-            mockResultRepo.findOne.mockResolvedValue(buildFormResult({
-                isDraft: true
-            }));
-            const result = await service.getMyDraft('form-uuid-1', buildMockUser());
-            expect(result?.isDraft).toBe(true);
-            expect(mockResultRepo.findOne).toHaveBeenCalledWith(expect.objectContaining({
-                where: expect.objectContaining({
-                    formId: 'form-uuid-1',
-                    isDraft: true
-                })
-            }));
-        });
-        it('returns null when the user has no draft', async ()=>{
-            await buildService(false);
-            mockResultRepo.findOne.mockResolvedValue(null);
-            const result = await service.getMyDraft('form-uuid-1', buildMockUser());
-            expect(result).toBeNull();
-        });
-    });
-    // ==========================================================================
-    // updateDraft
-    // ==========================================================================
-    describe('updateDraft', ()=>{
-        it('throws NotFoundException when the draft does not exist or does not belong to the user', async ()=>{
-            await buildService(false);
-            mockResultRepo.findOne.mockResolvedValue(null);
-            await expect(service.updateDraft('missing-draft', {
-                formId: 'form-uuid-1',
-                data: {}
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'form.result.not.found'
-                })
-            });
-        });
-        it('updates the draft with the latest form schema snapshot and data', async ()=>{
-            await buildService(false);
-            const existingDraft = buildFormResult({
-                id: 'draft-1',
-                isDraft: true
-            });
-            mockResultRepo.findOne.mockResolvedValue(existingDraft);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                schemaVersion: 2
-            }));
-            mockResultRepo.save.mockResolvedValue({
-                ...existingDraft,
-                schemaVersion: 2
-            });
-            const result = await service.updateDraft('draft-1', {
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'updated'
-                }
-            }, buildMockUser());
-            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                id: 'draft-1',
-                schemaVersion: 2
-            }));
-            expect(result).toBeDefined();
-        });
-        it('finalizes a draft (isDraft=false) and applies computed fields', async ()=>{
-            await buildService(false);
-            const existingDraft = buildFormResult({
-                id: 'draft-1',
-                isDraft: true
-            });
-            mockResultRepo.findOne.mockResolvedValue(existingDraft);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                schema: {
-                    settings: {
-                        computedFields: [
-                            {
-                                id: 'cf-1',
-                                name: 'Total',
-                                key: 'total',
-                                valueType: 'number',
-                                rules: [
-                                    {
-                                        id: 'r1',
-                                        computation: {
-                                            type: 'direct',
-                                            config: {
-                                                type: 'direct',
-                                                value: 7
-                                            }
-                                        }
-                                    }
-                                ]
-                            }
-                        ]
-                    }
-                }
-            }));
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                id: 'draft-1',
-                isDraft: false
-            }));
-            await service.updateDraft('draft-1', {
-                formId: 'form-uuid-1',
-                data: {
-                    field1: 'final'
-                },
-                isDraft: false
-            }, buildMockUser());
-            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                data: {
-                    field1: 'final',
-                    _computed: {
-                        total: 7
-                    }
-                },
-                isDraft: false
-            }));
-        });
-    });
-    // ==========================================================================
-    // getByFormId
-    // ==========================================================================
-    describe('getByFormId', ()=>{
-        it('returns paginated results scoped to the given form', async ()=>{
-            await buildService(false);
-            const qb = mockResultRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [
-                    buildFormResult()
-                ],
-                1
-            ]);
-            const result = await service.getByFormId('form-uuid-1', buildMockUser(), {
-                page: 0,
-                pageSize: 10
-            });
-            expect(qb.where).toHaveBeenCalledWith('form_result.formId = :formId', {
-                formId: 'form-uuid-1'
-            });
-            expect(result.total).toBe(1);
-            expect(result.data).toHaveLength(1);
-        });
-        it('applies default pagination when none is provided', async ()=>{
-            await buildService(false);
-            const qb = mockResultRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [],
-                0
-            ]);
-            await service.getByFormId('form-uuid-1', buildMockUser());
-            expect(qb.skip).toHaveBeenCalledWith(0);
-            expect(qb.take).toHaveBeenCalledWith(10);
-        });
-    });
-    // ==========================================================================
-    // hasUserSubmitted
-    // ==========================================================================
-    describe('hasUserSubmitted', ()=>{
-        it('returns true when a non-draft submission exists', async ()=>{
-            await buildService(false);
-            mockResultRepo.count.mockResolvedValue(1);
-            const result = await service.hasUserSubmitted('form-uuid-1', buildMockUser());
-            expect(result).toBe(true);
-            expect(mockResultRepo.count).toHaveBeenCalledWith(expect.objectContaining({
-                where: expect.objectContaining({
-                    formId: 'form-uuid-1',
-                    isDraft: false
-                })
-            }));
-        });
-        it('returns false when no non-draft submission exists', async ()=>{
-            await buildService(false);
-            mockResultRepo.count.mockResolvedValue(0);
-            const result = await service.hasUserSubmitted('form-uuid-1', buildMockUser());
-            expect(result).toBe(false);
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            EventBusRegistry.reset();
-            EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            EventBusRegistry.configureModule('form-builder', {
-                enabled: true
-            });
-        });
-        afterEach(()=>{
-            EventBusRegistry.reset();
-        });
-        it('publishes form-builder.form_result.submitted for a final submission', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.PUBLIC
-            }));
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                isDraft: false
-            }));
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {}
-            }, null, true);
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'form-builder.form_result.submitted',
-                action: 'submitted',
-                payload: expect.objectContaining({
-                    ids: [
-                        'result-uuid-1'
-                    ],
-                    metadata: expect.objectContaining({
-                        formId: 'form-uuid-1',
-                        isDraft: false
-                    })
-                })
-            }));
-        });
-        it('publishes form-builder.form_result.draft-saved when the submission is a draft', async ()=>{
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.PUBLIC
-            }));
-            mockResultRepo.save.mockResolvedValue(buildFormResult({
-                isDraft: true
-            }));
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {},
-                isDraft: true
-            }, null, true);
-            expect(publish.mock.calls[0][0].name).toBe('form-builder.form_result.draft-saved');
-        });
-        it('does not publish when the module has events disabled', async ()=>{
-            EventBusRegistry.configureModule('form-builder', {
-                enabled: false
-            });
-            await buildService(false);
-            mockFormRepo.findOne.mockResolvedValue(buildForm({
-                accessType: FormAccessType.PUBLIC
-            }));
-            mockResultRepo.save.mockResolvedValue(buildFormResult());
-            await service.submitForm({
-                formId: 'form-uuid-1',
-                data: {}
-            }, null, true);
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});