generator-jhipster 8.7.0 → 8.7.1

package/dist/jdl/validators/jdl-without-application-validator.js

@@ -1,179 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { applicationTypes, binaryOptions, databaseTypes, fieldTypes, relationshipOptions } from '../jhipster/index.js';
-import { isReservedFieldName, isReservedPaginationWords, isReservedTableName } from '../jhipster/reserved-keywords.js';
-import EntityValidator from './entity-validator.js';
-import FieldValidator from './field-validator.js';
-import ValidationValidator from './validation-validator.js';
-import RelationshipValidator from './relationship-validator.js';
-import EnumValidator from './enum-validator.js';
-import DeploymentValidator from './deployment-validator.js';
-import UnaryOptionValidator from './unary-option-validator.js';
-import BinaryOptionValidator from './binary-option-validator.js';
-const { BUILT_IN_ENTITY } = relationshipOptions;
-const { SQL } = databaseTypes;
-/**
- * Constructor taking the jdl object to check against application settings.
- * @param {JDLObject} jdlObject -  the jdl object to check.
- * @param {Object} [applicationSettings] - the settings object.
- * @param {String} applicationSettings.baseName - the application's name.
- * @param {String} applicationSettings.applicationType - the application type.
- * @param {String} applicationSettings.databaseType - the DB type.
- * @param {Array} applicationSettings.blueprints - the blueprints used.
- * @param {Object} [logger] - the logger to use, default to the console.
- * @param {Object} [options]
- */
-export default function createValidator(jdlObject, applicationSettings = {}, logger = console) {
-    if (!jdlObject) {
-        throw new Error('A JDL object must be passed to check for business errors.');
-    }
-    const { blueprints, databaseType } = applicationSettings;
-    const checkReservedKeywords = Boolean((databaseType ?? 'no') !== 'no') && (blueprints?.length ?? 0) === 0;
-    return {
-        checkForErrors: () => {
-            checkForEntityErrors({ checkReservedKeywords });
-            checkForRelationshipErrors();
-            checkForEnumErrors({ checkReservedKeywords });
-            if (checkReservedKeywords) {
-                checkDeploymentsErrors();
-                checkForOptionErrors();
-            }
-            else {
-                logger.warn('Blueprints are being used, the JDL validation phase is skipped.');
-            }
-        },
-    };
-    function checkForEntityErrors(options) {
-        if (jdlObject.getEntityQuantity() === 0) {
-            return;
-        }
-        const validator = new EntityValidator();
-        jdlObject.forEachEntity(jdlEntity => {
-            validator.validate(jdlEntity, options);
-            if (options.checkReservedKeywords) {
-                if (isReservedTableName(jdlEntity.tableName, applicationSettings.databaseType)) {
-                    logger.warn(`The table name '${jdlEntity.tableName}' is a reserved keyword, so it will be prefixed with the value of 'jhiPrefix'.`);
-                }
-            }
-            checkForFieldErrors(jdlEntity.name, jdlEntity.fields, options);
-        });
-    }
-    function checkForFieldErrors(entityName, jdlFields, options) {
-        const validator = new FieldValidator();
-        const filtering = applicationSettings.databaseType === SQL;
-        Object.keys(jdlFields).forEach(fieldName => {
-            const jdlField = jdlFields[fieldName];
-            validator.validate(jdlField);
-            if (options.checkReservedKeywords) {
-                if (isReservedFieldName(jdlField.name)) {
-                    logger.warn(`The name '${jdlField.name}' is a reserved keyword, so it will be prefixed with the value of 'jhiPrefix'.`);
-                }
-                if (filtering && isReservedPaginationWords(jdlField.name)) {
-                    throw new Error(`Field name '${fieldName}' found in ${entityName} is a reserved keyword, as it is used by Spring for pagination in the URL.`);
-                }
-            }
-            const typeCheckingFunction = getTypeCheckingFunction(entityName, applicationSettings);
-            const isAnEnum = jdlObject.hasEnum(jdlField.type);
-            if (!isAnEnum && !typeCheckingFunction(jdlField.type)) {
-                throw new Error(`The type '${jdlField.type}' is an unknown field type for field '${fieldName}' of entity '${entityName}'.`);
-            }
-            checkForValidationErrors(jdlField, isAnEnum);
-        });
-    }
-    function checkForValidationErrors(jdlField, isAnEnum) {
-        const validator = new ValidationValidator();
-        jdlField.forEachValidation(jdlValidation => {
-            validator.validate(jdlValidation);
-            if (!fieldTypes.hasValidation(jdlField.type, jdlValidation.name, isAnEnum)) {
-                throw new Error(`The validation '${jdlValidation.name}' isn't supported for the type '${jdlField.type}'.`);
-            }
-        });
-    }
-    function checkForRelationshipErrors() {
-        if (jdlObject.getRelationshipQuantity() === 0) {
-            return;
-        }
-        const validator = new RelationshipValidator();
-        jdlObject.forEachRelationship(jdlRelationship => {
-            validator.validate(jdlRelationship);
-            checkForAbsentEntities({
-                jdlRelationship,
-                doesEntityExist: entityName => !!jdlObject.getEntity(entityName),
-            });
-        });
-    }
-    function checkForEnumErrors(options) {
-        if (jdlObject.getEnumQuantity() === 0) {
-            return;
-        }
-        const validator = new EnumValidator();
-        jdlObject.forEachEnum(jdlEnum => {
-            validator.validate(jdlEnum, options);
-        });
-    }
-    function checkDeploymentsErrors() {
-        if (jdlObject.getDeploymentQuantity() === 0) {
-            return;
-        }
-        const validator = new DeploymentValidator();
-        jdlObject.forEachDeployment(deployment => {
-            validator.validate(deployment);
-        });
-    }
-    function checkForOptionErrors() {
-        if (jdlObject.getOptionQuantity() === 0) {
-            return;
-        }
-        const unaryOptionValidator = new UnaryOptionValidator();
-        const binaryOptionValidator = new BinaryOptionValidator();
-        jdlObject.getOptions().forEach(option => {
-            if (option.getType() === 'UNARY') {
-                unaryOptionValidator.validate(option);
-            }
-            else {
-                binaryOptionValidator.validate(option);
-            }
-            checkForPaginationInAppWithCassandra(option, applicationSettings);
-        });
-    }
-}
-function getTypeCheckingFunction(entityName, applicationSettings) {
-    if (applicationSettings.applicationType === applicationTypes.GATEWAY) {
-        return () => true;
-    }
-    return fieldTypes.getIsType(applicationSettings.databaseType);
-}
-function checkForAbsentEntities({ jdlRelationship, doesEntityExist, }) {
-    const absentEntities = [];
-    if (!doesEntityExist(jdlRelationship.from)) {
-        absentEntities.push(jdlRelationship.from);
-    }
-    if (!doesEntityExist(jdlRelationship.to) && !jdlRelationship.options.global[BUILT_IN_ENTITY]) {
-        absentEntities.push(jdlRelationship.to);
-    }
-    if (absentEntities.length !== 0) {
-        throw new Error(`In the relationship between ${jdlRelationship.from} and ${jdlRelationship.to}, ` +
-            `${absentEntities.join(' and ')} ${absentEntities.length === 1 ? 'is' : 'are'} not declared. If '${jdlRelationship.to}' is a built-in entity declare like '${jdlRelationship.from} to ${jdlRelationship.to} with builtInEntity'.`);
-    }
-}
-function checkForPaginationInAppWithCassandra(jdlOption, applicationSettings) {
-    if (applicationSettings.databaseType === databaseTypes.CASSANDRA && jdlOption.name === binaryOptions.Options.PAGINATION) {
-        throw new Error("Pagination isn't allowed when the application uses Cassandra.");
-    }
-}

package/dist/jdl/validators/relationship-validator.js

@@ -1,70 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { relationshipTypes } from '../jhipster/index.js';
-import { relationshipTypeExists } from '../jhipster/relationship-types.js';
-import Validator from './validator.js';
-const { ONE_TO_ONE, MANY_TO_MANY, MANY_TO_ONE, ONE_TO_MANY } = relationshipTypes;
-export default class RelationshipValidator extends Validator {
-    constructor() {
-        super('relationship', ['from', 'to', 'type']);
-    }
-    validate(jdlRelationship) {
-        super.validate(jdlRelationship);
-        checkType(jdlRelationship);
-        checkInjectedFields(jdlRelationship);
-        checkForRequiredReflexiveRelationship(jdlRelationship);
-        checkRelationshipType(jdlRelationship);
-    }
-}
-function checkType(jdlRelationship) {
-    if (!relationshipTypeExists(jdlRelationship.type)) {
-        throw new Error(`The relationship type '${jdlRelationship.type}' doesn't exist.`);
-    }
-}
-function checkInjectedFields(jdlRelationship) {
-    if (!(jdlRelationship.injectedFieldInFrom || jdlRelationship.injectedFieldInTo)) {
-        throw new Error('At least one injected field is required.');
-    }
-}
-function checkForRequiredReflexiveRelationship(jdlRelationship) {
-    if (jdlRelationship.from.toLowerCase() === jdlRelationship.to.toLowerCase() &&
-        (jdlRelationship.isInjectedFieldInFromRequired || jdlRelationship.isInjectedFieldInToRequired)) {
-        throw new Error(`Required relationships to the same entity are not supported, for relationship from and to '${jdlRelationship.from}'.`);
-    }
-}
-function checkRelationshipType(jdlRelationship) {
-    switch (jdlRelationship.type) {
-        case ONE_TO_ONE:
-            checkOneToOneRelationship(jdlRelationship);
-            break;
-        case MANY_TO_ONE:
-        case MANY_TO_MANY:
-        case ONE_TO_MANY:
-            return;
-        default:
-            // never happens, ever.
-            throw new Error(`This case shouldn't have happened with type ${jdlRelationship.type}.`);
-    }
-}
-function checkOneToOneRelationship(jdlRelationship) {
-    if (!jdlRelationship.injectedFieldInFrom) {
-        throw new Error(`In the One-to-One relationship from ${jdlRelationship.from} to ${jdlRelationship.to}, ` +
-            'the source entity must possess the destination, or you must invert the direction of the relationship.');
-    }
-}

package/dist/jdl/validators/validation-validator.js

@@ -1,49 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { validations } from '../jhipster/index.js';
-import Validator from './validator.js';
-const { Validations: { exists, needsValue, MINLENGTH, MAXLENGTH, MAXBYTES, MINBYTES }, } = validations;
-export default class ValidationValidator extends Validator {
-    constructor() {
-        super('validation', ['name']);
-    }
-    validate(jdlValidation) {
-        super.validate(jdlValidation);
-        checkForInvalidName(jdlValidation);
-        checkForRequiredValue(jdlValidation);
-        if ([MINLENGTH, MAXLENGTH, MAXBYTES, MINBYTES].includes(jdlValidation.name)) {
-            checkForInvalidNumericValue(jdlValidation);
-        }
-    }
-}
-function checkForInvalidName(jdlValidation) {
-    if (!exists(jdlValidation.name)) {
-        throw new Error(`The validation ${jdlValidation.name} doesn't exist.`);
-    }
-}
-function checkForRequiredValue(jdlValidation) {
-    if (jdlValidation.value == null && needsValue(jdlValidation.name)) {
-        throw new Error(`The validation ${jdlValidation.name} requires a value.`);
-    }
-}
-function checkForInvalidNumericValue(jdlValidation) {
-    if (jdlValidation.value.toString().includes('.')) {
-        throw new Error(`Decimal values are forbidden for the ${jdlValidation.name} validation.`);
-    }
-}

package/dist/testing/get-generator.js

@@ -1,17 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-import { existsSync } from 'fs';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export const getGeneratorFolder = (generatorName) => {
-    return resolve(__dirname, '../generators', generatorName.split(':').join('/generators/'));
-};
-const getGenerator = (generatorName) => {
-    const generatorFolder = getGeneratorFolder(generatorName);
-    const resolved = resolve(generatorFolder, 'index.ts');
-    if (existsSync(resolved)) {
-        return resolved;
-    }
-    return resolve(generatorFolder, 'index.js');
-};
-export default getGenerator;

package/dist/testing/helpers.js

@@ -1,337 +0,0 @@
-import { basename, dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { merge, set, snakeCase } from 'lodash-es';
-import { RunContext, YeomanTest, result } from 'yeoman-test';
-import { globSync } from 'glob';
-import EnvironmentBuilder from '../cli/environment-builder.mjs';
-import { JHIPSTER_CONFIG_DIR } from '../generators/generator-constants.js';
-import { GENERATOR_WORKSPACES } from '../generators/generator-list.js';
-import { createJHipsterLogger, normalizePathEnd, parseCreationTimestamp } from '../generators/base/support/index.js';
-import BaseGenerator from '../generators/base/index.js';
-import { getPackageRoot, isDistFolder } from '../lib/index.js';
-import getGenerator from './get-generator.js';
-const runResult = result;
-export { runResult, runResult as result };
-const DEFAULT_TEST_SETTINGS = { forwardCwd: true };
-const DEFAULT_TEST_OPTIONS = { skipInstall: true };
-const DEFAULT_TEST_ENV_OPTIONS = { skipInstall: true, dryRun: false };
-const generatorsDir = join(fileURLToPath(import.meta.url), '../../generators');
-const allGenerators = [
-    ...globSync('*/index.{j,t}s', { cwd: generatorsDir, posix: true }).map(file => dirname(file)),
-    ...globSync('*/generators/*/index.{j,t}s', { cwd: generatorsDir, posix: true }).map(file => dirname(file).replace('/generators/', ':')),
-]
-    .map(gen => `jhipster:${gen}`)
-    .sort();
-const filterBootstrapGenerators = (gen) => !gen.startsWith('jhipster:bootstrap-');
-const composedGeneratorsToCheck = allGenerators
-    .filter(filterBootstrapGenerators)
-    .filter(gen => !['jhipster:bootstrap', 'jhipster:project-name'].includes(gen));
-const defaultSharedApplication = Object.fromEntries(['CLIENT_WEBPACK_DIR'].map(key => [key, undefined]));
-let defaultMockFactory;
-export const defineDefaults = async ({ mockFactory } = {}) => {
-    if (mockFactory) {
-        defaultMockFactory = mockFactory;
-    }
-    else if (!defaultMockFactory) {
-        try {
-            const { esmocha } = await import('esmocha');
-            defaultMockFactory = esmocha.fn;
-        }
-        catch {
-            throw new Error('loadMockFactory should be called before using mock');
-        }
-    }
-};
-const createFiles = (workspaceFolder, configuration, entities) => {
-    if (!configuration.baseName) {
-        throw new Error('baseName is required');
-    }
-    workspaceFolder = workspaceFolder ? normalizePathEnd(workspaceFolder) : workspaceFolder;
-    const entityFiles = entities
-        ? Object.fromEntries(entities?.map(entity => [`${workspaceFolder}${JHIPSTER_CONFIG_DIR}/${entity.name}.json`, entity]))
-        : {};
-    configuration = { entities: entities?.map(e => e.name), ...configuration };
-    return {
-        [`${workspaceFolder}.yo-rc.json`]: { 'generator-jhipster': configuration },
-        ...entityFiles,
-    };
-};
-export const createJHipsterConfigFiles = (configuration, entities) => createFiles('', configuration, entities);
-export const createBlueprintFiles = (blueprintPackage, { packageJson, generator = 'test-blueprint', generatorContent, files = {} } = {}) => {
-    generatorContent =
-        generatorContent ??
-            `export const createGenerator = async env => {
-    const BaseGenerator = await env.requireGenerator('jhipster:base');
-    return class extends BaseGenerator {
-      get [BaseGenerator.INITIALIZING]() {
-        return {};
-      }
-    };
-  };
-  `;
-    const generators = Array.isArray(generator) ? generator : [generator];
-    return {
-        [`node_modules/${blueprintPackage}/package.json`]: {
-            name: blueprintPackage,
-            version: '9.9.9',
-            type: 'module',
-            ...packageJson,
-        },
-        ...Object.fromEntries(generators.map(generator => [`node_modules/${blueprintPackage}/generators/${generator}/index.js`, generatorContent])),
-        ...Object.fromEntries(Object.entries(files).map(([file, content]) => [`node_modules/${blueprintPackage}/${file}`, content])),
-    };
-};
-class JHipsterRunContext extends RunContext {
-    sharedSource;
-    sharedData;
-    sharedApplication;
-    sharedControl;
-    workspaceApplications = [];
-    commonWorkspacesConfig;
-    generateApplicationsSet = false;
-    withOptions(options) {
-        return super.withOptions(options);
-    }
-    withJHipsterConfig(configuration, entities) {
-        return this.withFiles(createFiles('', { baseName: 'jhipster', creationTimestamp: parseCreationTimestamp('2020-01-01'), ...configuration }, entities));
-    }
-    withSkipWritingPriorities() {
-        return this.withOptions({ skipPriorities: ['writing', 'postWriting', 'writingEntities', 'postWritingEntities'] });
-    }
-    withWorkspacesCommonConfig(commonWorkspacesConfig) {
-        if (this.workspaceApplications.length > 0) {
-            throw new Error('Cannot be called after withWorkspaceApplication');
-        }
-        this.commonWorkspacesConfig = { ...this.commonWorkspacesConfig, ...commonWorkspacesConfig };
-        return this;
-    }
-    withWorkspaceApplicationAtFolder(workspaceFolder, configuration, entities) {
-        if (this.generateApplicationsSet) {
-            throw new Error('Cannot be called after withWorkspaceApplication');
-        }
-        this.workspaceApplications.push(workspaceFolder);
-        return this.withFiles(createFiles(workspaceFolder, { ...configuration, ...this.commonWorkspacesConfig }, entities));
-    }
-    withWorkspaceApplication(configuration, entities) {
-        return this.withWorkspaceApplicationAtFolder(configuration.baseName, configuration, entities);
-    }
-    withWorkspacesSamples(...appNames) {
-        return this.onBeforePrepare(async () => {
-            try {
-                const { default: deploymentTestSamples } = await import('./support/deployment-samples.js');
-                for (const appName of appNames) {
-                    const application = deploymentTestSamples[appName];
-                    if (!application) {
-                        throw new Error(`Application ${appName} not found`);
-                    }
-                    this.withWorkspaceApplicationAtFolder(appName, deploymentTestSamples[appName]);
-                }
-            }
-            catch {
-                throw new Error('Samples are currently not available to blueprint testing.');
-            }
-        });
-    }
-    withGenerateWorkspaceApplications(generateWorkspaces = false) {
-        return this.onBeforePrepare(() => {
-            this.generateApplicationsSet = true;
-            this.withOptions({ generateApplications: true, workspacesFolders: this.workspaceApplications, workspaces: generateWorkspaces });
-        });
-    }
-    withJHipsterLookup() {
-        return this.withLookups([{ packagePaths: [getPackageRoot()], lookups: [`${isDistFolder() ? 'dist/' : ''}generators`] }]);
-    }
-    /**
-     * Lookup generators at generator-jhipster's parent at a npm repository
-     * @param lookups generators relative folder
-     * @returns
-     */
-    withParentBlueprintLookup(lookups = ['generators']) {
-        const packageRootParent = join(getPackageRoot(), '..');
-        if (basename(packageRootParent) === 'node_modules') {
-            this.withLookups([{ packagePaths: [join(packageRootParent, '..')], lookups }]);
-        }
-        else {
-            // Try to lookup at current path for linked generator-jhipster.
-            this.withLookups([{ packagePaths: [process.cwd()], lookups }]);
-        }
-        return this;
-    }
-    withFakeTestBlueprint(blueprintPackage, { packageJson, generator = 'test-blueprint' } = {}) {
-        return this.withFiles(createBlueprintFiles(blueprintPackage, { packageJson, generator }))
-            .withLookups({ localOnly: true })
-            .commitFiles();
-    }
-    withMockedSource() {
-        this.sharedSource = new Proxy({}, {
-            get(target, name) {
-                if (!target[name]) {
-                    target[name] = defaultMockFactory();
-                }
-                return target[name];
-            },
-            set() {
-                return true;
-            },
-        });
-        return this.onBeforePrepare(() => defineDefaults()).withSharedData({ sharedSource: this.sharedSource });
-    }
-    withControl(sharedControl) {
-        this.sharedControl = this.sharedControl ?? {};
-        Object.assign(this.sharedControl, sharedControl);
-        return this.withSharedData({ control: this.sharedControl });
-    }
-    withSharedApplication(sharedApplication) {
-        this.sharedApplication = this.sharedApplication ?? { ...defaultSharedApplication };
-        merge(this.sharedApplication, sharedApplication);
-        return this.withSharedData({ sharedApplication: this.sharedApplication });
-    }
-    withMockedNodeDependencies() {
-        return this.withSharedApplication({
-            nodeDependencies: new Proxy({}, { get: (_target, prop) => `${snakeCase(prop.toString()).toUpperCase()}_VERSION` }),
-        });
-    }
-    /**
-     * Mock every built-in generators except the ones in the except and bootstrap-* generators.
-     * Note: Boostrap generator is mocked by default.
-     * @example
-     * withMockedJHipsterGenerators({ except: ['jhipster:bootstrap'] })
-     * @example
-     * withMockedJHipsterGenerators({ except: ['bootstrap', 'server'] })
-     * @example
-     * // Mock every generator including bootstrap-*
-     * withMockedJHipsterGenerators({ filter: () => true })
-     */
-    withMockedJHipsterGenerators(options = {}) {
-        const optionsObj = Array.isArray(options) ? { except: options } : options;
-        const { except = [], filter = filterBootstrapGenerators } = optionsObj;
-        const jhipsterExceptList = except.map(gen => (gen.startsWith('jhipster:') ? gen : `jhipster:${gen}`));
-        return this.withMockedGenerators(allGenerators.filter(filter).filter(gen => !jhipsterExceptList.includes(gen) && this.Generator !== gen));
-    }
-    withGradleBuildTool() {
-        return this.withFiles({
-            'build.gradle': `
-dependencies {
-// jhipster-needle-gradle-dependency
-}
-plugins {
-// jhipster-needle-gradle-plugins
-}
-`,
-        }).withJHipsterConfig({ buildTool: 'gradle' });
-    }
-    withSharedData(sharedData) {
-        if (!this.sharedData) {
-            const applicationId = 'test-application';
-            this.sharedData = { ...sharedData };
-            set(this.envOptions, `sharedOptions.sharedData.applications.${applicationId}`, this.sharedData);
-            return this.withOptions({
-                applicationId,
-            });
-        }
-        Object.assign(this.sharedData, sharedData);
-        return this;
-    }
-    async run() {
-        const runResult = (await super.run());
-        if (this.sharedSource) {
-            const sourceCallsArg = Object.fromEntries(Object.entries(this.sharedSource).map(([name, fn]) => [name, fn.mock.calls.map(args => (args.length > 1 ? args : args[0]))]));
-            if (sourceCallsArg.addEntitiesToClient) {
-                sourceCallsArg.addEntitiesToClient = sourceCallsArg.addEntitiesToClient.map(({ application, entities }) => ({
-                    application: `Application[${application.baseName}]`,
-                    entities: entities.map(entity => `Entity[${entity.name}]`),
-                }));
-            }
-            if (sourceCallsArg.addEntityToCache) {
-                sourceCallsArg.addEntityToCache = sourceCallsArg.addEntityToCache.map(({ relationships, ...fields }) => ({
-                    ...fields,
-                    relationships: relationships.map(rel => `Relationship[${rel.relationshipName}]`),
-                }));
-            }
-            runResult.sourceCallsArg = sourceCallsArg;
-        }
-        runResult.composedMockedGenerators = composedGeneratorsToCheck.filter(gen => runResult.mockedGenerators[gen]?.called);
-        return runResult;
-    }
-}
-class JHipsterTest extends YeomanTest {
-    constructor() {
-        super();
-        this.adapterOptions = { log: createJHipsterLogger() };
-    }
-    // @ts-expect-error testing types should be improved
-    run(GeneratorOrNamespace, settings, envOptions) {
-        return super.run(GeneratorOrNamespace, settings, envOptions).withAdapterOptions({ log: createJHipsterLogger() });
-    }
-    runJHipster(jhipsterGenerator, settings, envOptions) {
-        return this.run(getGenerator(jhipsterGenerator), settings, envOptions);
-    }
-    runTestBlueprintGenerator() {
-        const blueprintNS = 'jhipster:test-blueprint';
-        class BlueprintedGenerator extends BaseGenerator {
-            async beforeQueue() {
-                if (!this.fromBlueprint) {
-                    await this.composeWithBlueprints();
-                }
-            }
-            rootGeneratorName() {
-                // Force fromBlueprint to be false.
-                return 'generator-jhipster';
-            }
-            get [BaseGenerator.INITIALIZING]() {
-                return {};
-            }
-        }
-        return this.run(blueprintNS).withGenerators([[BlueprintedGenerator, { namespace: blueprintNS }]]);
-    }
-    // @ts-expect-error testing types should be improved
-    create(GeneratorOrNamespace, settings, envOptions) {
-        return super.create(GeneratorOrNamespace, settings, envOptions);
-    }
-    createJHipster(jhipsterGenerator, settings, envOptions) {
-        return this.create(getGenerator(jhipsterGenerator), settings, envOptions);
-    }
-    generateDeploymentWorkspaces(commonConfig) {
-        return this.runJHipster(GENERATOR_WORKSPACES)
-            .withWorkspacesCommonConfig(commonConfig ?? {})
-            .withOptions({
-            generateWorkspaces: true,
-            generateWith: 'docker',
-            skipPriorities: ['prompting'],
-        });
-    }
-}
-export function createTestHelpers(options = {}) {
-    const { environmentOptions = {} } = options;
-    const sharedOptions = {
-        ...DEFAULT_TEST_OPTIONS,
-        ...environmentOptions.sharedOptions,
-    };
-    const helper = new JHipsterTest();
-    helper.settings = { ...DEFAULT_TEST_SETTINGS, ...options.settings };
-    helper.environmentOptions = { ...DEFAULT_TEST_ENV_OPTIONS, ...environmentOptions, sharedOptions };
-    helper.generatorOptions = { ...DEFAULT_TEST_OPTIONS, ...options.generatorOptions };
-    helper.createEnv = (...args) => EnvironmentBuilder.createEnv(...args);
-    // @ts-expect-error testing types should be improved
-    helper.getRunContextType = () => JHipsterRunContext;
-    return helper;
-}
-const commonTestOptions = {
-    reproducible: true,
-    skipChecks: true,
-    reproducibleTests: true,
-    noInsight: true,
-    useVersionPlaceholders: true,
-    fakeKeytool: true,
-    skipGit: true,
-};
-export const basicHelpers = createTestHelpers({ generatorOptions: { ...commonTestOptions } });
-export const defaultHelpers = createTestHelpers({
-    generatorOptions: { skipPrettier: true, ...commonTestOptions },
-    environmentOptions: { dryRun: true },
-});
-export const skipPrettierHelpers = createTestHelpers({ generatorOptions: { skipPrettier: true, ...commonTestOptions } });
-export const dryRunHelpers = createTestHelpers({
-    generatorOptions: { ...commonTestOptions },
-    environmentOptions: { dryRun: true },
-});