generator-jhipster 8.7.0 → 8.7.1

package/dist/lib/testing/helpers.d.ts

@@ -0,0 +1,108 @@
+import type { RunContextSettings, RunResult } from 'yeoman-test';
+import { RunContext, YeomanTest } from 'yeoman-test';
+import type { BaseEnvironmentOptions, GetGeneratorConstructor, BaseGenerator as YeomanGenerator } from '@yeoman/types';
+import type { EmptyObject } from 'type-fest';
+import type { JHipsterGeneratorOptions } from '../../generators/base/api.js';
+import type CoreGenerator from '../../generators/base-core/generator.js';
+import type { ApplicationConfiguration } from '../types/application/yo-rc.js';
+import type { Entity } from '../types/base/entity.js';
+type GeneratorTestType = YeomanGenerator<JHipsterGeneratorOptions>;
+type GeneratorTestOptions = JHipsterGeneratorOptions;
+type JHipsterRunResult<GeneratorType extends CoreGenerator = CoreGenerator> = RunResult<GeneratorType> & {
+    /**
+     * First argument of mocked source calls.
+     */
+    sourceCallsArg: Record<string, unknown[]>;
+    /**
+     * Composed generators that were mocked.
+     */
+    composedMockedGenerators: string[];
+};
+declare const runResult: JHipsterRunResult;
+export { runResult, runResult as result };
+export declare const defineDefaults: ({ mockFactory, accumulateMockArgs, }?: {
+    mockFactory?: any;
+    accumulateMockArgs?: (mock: Record<string, any>) => Record<string, any>;
+}) => Promise<void>;
+export declare const createJHipsterConfigFiles: (configuration: Record<string, unknown>, entities?: Entity[]) => Record<string, any>;
+export type FakeBlueprintOptions = {
+    packageJson?: any;
+    generator?: string | string[];
+    generatorContent?: string;
+    files?: Record<string, unknown>;
+};
+export declare const createBlueprintFiles: (blueprintPackage: string, { packageJson, generator, generatorContent, files }?: FakeBlueprintOptions) => {
+    [x: string]: any;
+};
+declare class JHipsterRunContext extends RunContext<GeneratorTestType> {
+    sharedSource: Record<string, any>;
+    private sharedData;
+    private sharedApplication;
+    private sharedControl;
+    private workspaceApplications;
+    private commonWorkspacesConfig;
+    private generateApplicationsSet;
+    withOptions(options: Partial<Omit<JHipsterGeneratorOptions, 'env' | 'resolved' | 'namespace'> & Record<string, any>>): this;
+    withJHipsterConfig<Config extends EmptyObject>(configuration?: Readonly<Partial<Config & ApplicationConfiguration>>, entities?: Entity[]): this;
+    withSkipWritingPriorities(): this;
+    withWorkspacesCommonConfig(commonWorkspacesConfig: Record<string, unknown>): this;
+    withWorkspaceApplicationAtFolder(workspaceFolder: string, configuration: Record<string, unknown>, entities?: Entity[]): this;
+    withWorkspaceApplication(configuration: Record<string, unknown>, entities?: Entity[]): this;
+    withWorkspacesSamples(...appNames: string[]): this;
+    withGenerateWorkspaceApplications(generateWorkspaces?: boolean): this;
+    withJHipsterLookup(): this;
+    /**
+     * Lookup generators at generator-jhipster's parent at a npm repository
+     * @param lookups generators relative folder
+     * @returns
+     */
+    withParentBlueprintLookup(lookups?: string[]): this;
+    withFakeTestBlueprint(blueprintPackage: string, { packageJson, generator }?: FakeBlueprintOptions): this;
+    withMockedSource(options?: {
+        except?: string[];
+    }): this;
+    withControl(sharedControl: Record<string, any>): this;
+    withSharedApplication(sharedApplication: Record<string, any>): this;
+    withMockedNodeDependencies(): this;
+    /**
+     * 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?: string[] | {
+        except?: string[];
+        filter?: (string: any) => boolean;
+    }): this;
+    withGradleBuildTool(): this;
+    private withSharedData;
+    run(): Promise<RunResult<GeneratorTestType>>;
+}
+declare class JHipsterTest extends YeomanTest {
+    constructor();
+    run<GeneratorType extends YeomanGenerator<GeneratorTestOptions> = YeomanGenerator<GeneratorTestOptions>>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings | undefined, envOptions?: BaseEnvironmentOptions | undefined): JHipsterRunContext;
+    runJHipster(jhipsterGenerator: string, settings?: RunContextSettings | undefined, envOptions?: BaseEnvironmentOptions | undefined): JHipsterRunContext;
+    /**
+     * Run a generator in current application context.
+     */
+    runJHipsterInApplication(jhipsterGenerator: string, settings?: RunContextSettings | undefined, envOptions?: BaseEnvironmentOptions | undefined): JHipsterRunContext;
+    runJDL(jdl: string, settings?: RunContextSettings | undefined, envOptions?: BaseEnvironmentOptions | undefined): JHipsterRunContext;
+    /**
+     * Run the JDL generator in current application context.
+     */
+    runJDLInApplication(jdl: string, settings?: RunContextSettings | undefined, envOptions?: BaseEnvironmentOptions | undefined): JHipsterRunContext;
+    runTestBlueprintGenerator(): JHipsterRunContext;
+    create<GeneratorType extends YeomanGenerator<GeneratorTestOptions> = YeomanGenerator<GeneratorTestOptions>>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings | undefined, envOptions?: BaseEnvironmentOptions | undefined): JHipsterRunContext;
+    createJHipster(jhipsterGenerator: string, settings?: RunContextSettings | undefined, envOptions?: BaseEnvironmentOptions | undefined): JHipsterRunContext;
+    generateDeploymentWorkspaces(commonConfig?: Record<string, unknown>): JHipsterRunContext;
+}
+export declare function createTestHelpers(options?: any): JHipsterTest;
+export declare const basicHelpers: JHipsterTest;
+export declare const defaultHelpers: JHipsterTest;
+export declare const skipPrettierHelpers: JHipsterTest;
+export declare const dryRunHelpers: JHipsterTest;

package/dist/lib/testing/helpers.js

@@ -0,0 +1,384 @@
+import { basename, dirname, join } from 'path';
+import { mock } from 'node:test';
+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 '../index.js';
+import { getDefaultJDLApplicationConfig } from '../command/jdl.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(getPackageRoot(), '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;
+let defaultAccumulateMockArgs;
+export const defineDefaults = async ({ mockFactory, accumulateMockArgs, } = {}) => {
+    if (mockFactory) {
+        defaultMockFactory = mockFactory;
+    }
+    else if (!defaultMockFactory) {
+        try {
+            defaultMockFactory = (...args) => mock.fn(...args);
+        }
+        catch {
+            throw new Error('loadMockFactory should be called before using mock');
+        }
+    }
+    if (!defaultAccumulateMockArgs) {
+        defaultAccumulateMockArgs =
+            accumulateMockArgs ??
+                ((mocks = {}) => Object.fromEntries(Object.entries(mocks)
+                    .filter(([_name, fn]) => fn.mock)
+                    .map(([name, fn]) => [name, fn.mock.calls.map(call => (call.arguments.length > 1 ? call.arguments : call.arguments[0]))])));
+    }
+};
+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(options = {}) {
+        const { except = [] } = options;
+        this.sharedSource = new Proxy({}, {
+            get(target, name) {
+                if (!target[name]) {
+                    target[name] = defaultMockFactory();
+                }
+                return target[name];
+            },
+            set(target, property, value) {
+                if (except.includes(property)) {
+                    if (target[property]) {
+                        throw new Error(`Cannot set ${property} mock`);
+                    }
+                    target[property] = defaultMockFactory(value);
+                }
+                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) {
+            // Convert big objects to an identifier to avoid big snapshot and serialization issues.
+            const cleanupArguments = (args) => args.map(arg => {
+                if (Array.isArray(arg)) {
+                    return cleanupArguments(arg);
+                }
+                const { application, relationships, entities, entity } = arg;
+                if (application) {
+                    arg = { ...arg, application: `Application[${application.baseName}]` };
+                }
+                if (entity) {
+                    arg = { ...arg, entity: `Entity[${entity.name}]` };
+                }
+                for (const key of ['control', 'entities', 'source'].filter(key => arg[key])) {
+                    arg = { ...arg, [key]: `TaskParameter[${key}]` };
+                }
+                if (relationships) {
+                    arg = { ...arg, relationships: relationships.map(rel => `Relationship[${rel.relationshipName}]`) };
+                }
+                if (entities) {
+                    arg = { ...arg, entities: entities.map(entity => `Entity[${entity.name}]`) };
+                }
+                return arg;
+            });
+            runResult.sourceCallsArg = Object.fromEntries(Object.entries(defaultAccumulateMockArgs(this.sharedSource)).map(([name, args]) => [name, cleanupArguments(args)]));
+        }
+        runResult.composedMockedGenerators = composedGeneratorsToCheck.filter(gen => runResult.mockedGenerators[gen]?.mock.callCount() > 0);
+        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)
+            .withOptions({
+            jdlDefinition: getDefaultJDLApplicationConfig(),
+        })
+            .withAdapterOptions({ log: createJHipsterLogger() });
+    }
+    runJHipster(jhipsterGenerator, settings, envOptions) {
+        return this.run(getGenerator(jhipsterGenerator), settings, envOptions);
+    }
+    /**
+     * Run a generator in current application context.
+     */
+    runJHipsterInApplication(jhipsterGenerator, settings, envOptions) {
+        return runResult.create(getGenerator(jhipsterGenerator), settings, envOptions);
+    }
+    runJDL(jdl, settings, envOptions) {
+        return this.runJHipster('jdl', settings, envOptions).withOptions({ inline: jdl });
+    }
+    /**
+     * Run the JDL generator in current application context.
+     */
+    runJDLInApplication(jdl, settings, envOptions) {
+        return this.runJHipsterInApplication('jdl', settings, envOptions).withOptions({ inline: jdl });
+    }
+    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,
+    skipEslint: true,
+    skipForks: 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 },
+});

package/dist/lib/testing/sample-config.d.ts

@@ -0,0 +1,4 @@
+import type { InfoFile } from '../../generators/info/support/extract-info.js';
+export declare const prepareSample: (projectFolder: string, files: InfoFile[], { removeBlueprints }?: {
+    removeBlueprints?: boolean;
+}) => Promise<InfoFile[]>;

package/dist/lib/testing/sample-config.js

@@ -0,0 +1,31 @@
+import { lstat, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { GENERATOR_JHIPSTER } from '../../generators/generator-constants.js';
+import { mutateData } from '../utils/object.js';
+const isFile = async (filename) => {
+    try {
+        return (await lstat(filename)).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+export const prepareSample = async (projectFolder, files, { removeBlueprints } = {}) => {
+    return Promise.all(files.map(async ({ filename, content }) => {
+        filename = join(projectFolder, filename);
+        if (filename.endsWith('.yo-rc.json')) {
+            if (await isFile(filename)) {
+                const { jwtSecretKey, rememberMeKey } = JSON.parse(await readFile(filename, 'utf-8'))[GENERATOR_JHIPSTER];
+                if (jwtSecretKey || rememberMeKey) {
+                    const newContent = JSON.parse(content);
+                    mutateData(newContent[GENERATOR_JHIPSTER], { jwtSecretKey, rememberMeKey });
+                    if (removeBlueprints) {
+                        delete newContent[GENERATOR_JHIPSTER].blueprints;
+                    }
+                    content = JSON.stringify(newContent, null, 2);
+                }
+            }
+        }
+        return { filename, content };
+    }));
+};

package/dist/lib/testing/support/application-samples.js

@@ -0,0 +1,22 @@
+import { applicationTypes, authenticationTypes } from '../../jhipster/index.js';
+const { JWT, OAUTH2, SESSION } = authenticationTypes;
+const { GATEWAY, MICROSERVICE, MONOLITH } = applicationTypes;
+export const AuthenticationTypeMatrix = {
+    authenticationType: [OAUTH2, JWT, SESSION],
+};
+export const MatrixMonolith = {
+    applicationType: [MONOLITH],
+    ...AuthenticationTypeMatrix,
+};
+export const MatrixMicroservice = {
+    applicationType: [MICROSERVICE],
+    authenticationType: [OAUTH2, JWT],
+};
+export const MatrixGateway = {
+    applicationType: [GATEWAY],
+    authenticationType: [OAUTH2, JWT],
+};
+export const MatrixMicroserviceGateway = {
+    applicationType: [MICROSERVICE, GATEWAY],
+    authenticationType: [OAUTH2, JWT],
+};

package/dist/lib/testing/support/entity-samples.js

@@ -0,0 +1,56 @@
+import { fieldTypes } from '../../jhipster/index.js';
+const { CommonDBTypes: { UUID }, } = fieldTypes;
+export const entitySimple = {
+    name: 'Simple',
+    changelogDate: '20220129000100',
+    jpaMetamodelFiltering: true,
+    fields: [{ fieldName: 'simpleName', fieldType: 'String' }],
+};
+export const entityAnotherSimple = {
+    name: 'AnotherSimple',
+    changelogDate: '20220129000200',
+    fields: [{ fieldName: 'simpleName', fieldType: 'String' }],
+    dto: 'mapstruct',
+    service: 'serviceImpl',
+    pagination: 'pagination',
+    clientRootFolder: 'test-root',
+};
+export const entitiesSimple = [entitySimple, entityAnotherSimple];
+export const entitiesWithRelationships = [
+    entitySimple,
+    entityAnotherSimple,
+    {
+        name: 'RelationshipWithSimple',
+        changelogDate: '20220129001000',
+        fields: [{ fieldName: 'twoName', fieldType: 'String' }],
+        relationships: [{ relationshipName: 'relationship', otherEntityName: 'Simple', relationshipType: 'many-to-one' }],
+    },
+];
+export const entityCustomId = {
+    name: 'EntityWithCustomId',
+    changelogDate: '20220129002000',
+    entityPackage: 'custom',
+    fields: [
+        {
+            fieldName: 'id',
+            fieldType: UUID,
+        },
+    ],
+};
+export const entitiesMicroservice = {
+    name: 'Microservice',
+    skipFakeData: true,
+    changelogDate: '20220129000300',
+    fields: [{ fieldName: 'simpleName', fieldType: 'String' }],
+    microserviceName: 'microservice1',
+    service: 'service',
+    pagination: 'infiniscroll',
+};
+export const entitySkipClient = {
+    name: 'SkipClient',
+    changelogDate: '20220129000400',
+    skipClient: true,
+    fields: [{ fieldName: 'skipClientName', fieldType: 'String' }],
+};
+export const entitiesServerSamples = [entitySimple, entityAnotherSimple, entityCustomId, entitiesMicroservice];
+export const entitiesClientSamples = [entitySimple, entityCustomId, entitiesMicroservice, entitySkipClient];

package/dist/lib/testing/support/matcher.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Requires a global `it` function to be available.
+ *
+ * @example
+ * it(..matchWrittenFiles('eureka', () => ['file'], true));
+ */
+export declare const matchWrittenFiles: (title: string, expectedFilesGetter: () => string[], shouldMatch: boolean, runResult?: import("yeoman-test").RunResult<import("@yeoman/types").BaseGenerator>) => [string, () => void];
+/**
+ * Requires a global `it` function to be available.
+ *
+ * @example
+ * it(..matchWrittenFiles('eureka', { 'generator-jhipster': { config: true } }, true));
+ */
+export declare const matchWrittenConfig: (title: string, config: any, shouldMatch: boolean, runResult?: import("yeoman-test").RunResult<import("@yeoman/types").BaseGenerator>) => [string, () => void];

package/dist/lib/testing/support/matcher.js

@@ -0,0 +1,35 @@
+import { result } from 'yeoman-test';
+/**
+ * Requires a global `it` function to be available.
+ *
+ * @example
+ * it(..matchWrittenFiles('eureka', () => ['file'], true));
+ */
+export const matchWrittenFiles = (title, expectedFilesGetter, shouldMatch, runResult = result) => [
+    shouldMatch ? `writes ${title} files` : `doesn't write ${title} files`,
+    () => {
+        if (shouldMatch) {
+            runResult.assertFile(expectedFilesGetter());
+        }
+        else {
+            runResult.assertNoFile(expectedFilesGetter());
+        }
+    },
+];
+/**
+ * Requires a global `it` function to be available.
+ *
+ * @example
+ * it(..matchWrittenFiles('eureka', { 'generator-jhipster': { config: true } }, true));
+ */
+export const matchWrittenConfig = (title, config, shouldMatch, runResult = result) => [
+    shouldMatch ? `writes ${title} config` : `doesn't write ${title} config`,
+    () => {
+        if (shouldMatch) {
+            runResult.assertJsonFileContent('.yo-rc.json', config);
+        }
+        else {
+            runResult.assertNoJsonFileContent('.yo-rc.json', config);
+        }
+    },
+];

package/dist/lib/types/application/application.d.ts

@@ -0,0 +1,7 @@
+import type { BaseApplication, CommonClientServerApplication } from '../../../generators/base-application/types.js';
+import type { ClientSourceType } from '../../../generators/client/types.js';
+import type { LanguagesSource } from '../../../generators/languages/types.js';
+import type { SpringBootSourceType } from '../../../generators/server/types.js';
+
+export type ApplicationType<Entity> = BaseApplication & Partial<CommonClientServerApplication<Entity>>;
+export type BaseApplicationSource = SpringBootSourceType & ClientSourceType & LanguagesSource;