diff --git a/common/changes/@microsoft/rush/environment-snapshot_2026-09-16.json b/common/changes/@microsoft/rush/environment-snapshot_2026-09-16.json new file mode 100644 index 00000000000..780e33b7472 --- /dev/null +++ b/common/changes/@microsoft/rush/environment-snapshot_2026-09-16.json @@ -0,0 +1,10 @@ +{ + "changes": [ + { + "packageName": "@microsoft/rush", + "comment": "Fix declared-environment cache hashes to distinguish unset and empty values, encode values unambiguously, and use Windows environment-variable name semantics. Operations with declared environment inputs receive new cache keys.", + "type": "patch" + } + ], + "packageName": "@microsoft/rush" +} diff --git a/common/changes/@rushstack/node-core-library/environment-map-equals_2026-11-16.json b/common/changes/@rushstack/node-core-library/environment-map-equals_2026-11-16.json new file mode 100644 index 00000000000..d363821cc4d --- /dev/null +++ b/common/changes/@rushstack/node-core-library/environment-map-equals_2026-11-16.json @@ -0,0 +1,10 @@ +{ + "changes": [ + { + "packageName": "@rushstack/node-core-library", + "comment": "Add EnvironmentMap.equals() to compare variable names and values without allocating temporary arrays.", + "type": "minor" + } + ], + "packageName": "@rushstack/node-core-library" +} diff --git a/common/reviews/api/node-core-library.api.md b/common/reviews/api/node-core-library.api.md index 679736f30f6..1d6ca3717ed 100644 --- a/common/reviews/api/node-core-library.api.md +++ b/common/reviews/api/node-core-library.api.md @@ -98,6 +98,7 @@ export class EnvironmentMap { readonly caseSensitive: boolean; clear(): void; entries(): IterableIterator; + equals(environmentMap: EnvironmentMap): boolean; get(name: string): string | undefined; mergeFrom(environmentMap: EnvironmentMap): void; mergeFromObject(environmentObject?: Record): void; diff --git a/libraries/node-core-library/src/EnvironmentMap.ts b/libraries/node-core-library/src/EnvironmentMap.ts index c672f1be36b..b73e03fdb29 100644 --- a/libraries/node-core-library/src/EnvironmentMap.ts +++ b/libraries/node-core-library/src/EnvironmentMap.ts @@ -106,6 +106,23 @@ export class EnvironmentMap { return this._map.values(); } + /** + * Returns whether the maps have the same case sensitivity, variable names, and values. + * Entry order and, for case-insensitive maps, variable name casing are ignored. + */ + public equals(environmentMap: EnvironmentMap): boolean { + if (this.caseSensitive !== environmentMap.caseSensitive || this._map.size !== environmentMap._map.size) { + return false; + } + + for (const [name, entry] of this._map) { + if (environmentMap._map.get(name)?.value !== entry.value) { + return false; + } + } + return true; + } + /** * Adds each entry from `environmentMap` to this map. */ diff --git a/libraries/node-core-library/src/test/EnvironmentMap.test.ts b/libraries/node-core-library/src/test/EnvironmentMap.test.ts index be51e8163b4..bdce9a2a5d1 100644 --- a/libraries/node-core-library/src/test/EnvironmentMap.test.ts +++ b/libraries/node-core-library/src/test/EnvironmentMap.test.ts @@ -6,6 +6,52 @@ import process from 'node:process'; import { EnvironmentMap } from '../EnvironmentMap'; describe(EnvironmentMap.name, () => { + describe(EnvironmentMap.prototype.equals.name, () => { + it('compares values and names independently of insertion order', () => { + const map = new EnvironmentMap({ A: '1', B: '' }); + expect(map.equals(new EnvironmentMap({ B: '', A: '1' }))).toBe(true); + expect(map.equals(new EnvironmentMap({ A: '2', B: '' }))).toBe(false); + expect(map.equals(new EnvironmentMap({ A: '1', C: '' }))).toBe(false); + expect(map.equals(new EnvironmentMap({ A: '1' }))).toBe(false); + expect(map.equals(new EnvironmentMap({ A: '1', B: '', C: '3' }))).toBe(false); + }); + + it('distinguishes empty values from missing variables', () => { + const missing = new EnvironmentMap(); + expect(missing.equals(new EnvironmentMap({ A: undefined }))).toBe(true); + expect(missing.equals(new EnvironmentMap({ A: '' }))).toBe(false); + expect(new EnvironmentMap({ A: '' }).equals(missing)).toBe(false); + }); + + it.each(['win32', 'linux'])('respects %s variable-name semantics', (platform) => { + const descriptor = Object.getOwnPropertyDescriptor(process, 'platform')!; + Object.defineProperty(process, 'platform', { ...descriptor, value: platform }); + try { + const upper = new EnvironmentMap({ A: '1' }); + const lower = new EnvironmentMap({ a: '1' }); + expect(upper.equals(lower)).toBe(platform === 'win32'); + expect(lower.equals(upper)).toBe(platform === 'win32'); + expect(upper.equals(new EnvironmentMap({ a: '2' }))).toBe(false); + } finally { + Object.defineProperty(process, 'platform', descriptor); + } + }); + + it('does not equate maps with different lookup semantics', () => { + const descriptor = Object.getOwnPropertyDescriptor(process, 'platform')!; + try { + Object.defineProperty(process, 'platform', { ...descriptor, value: 'win32' }); + const insensitive = new EnvironmentMap({ A: '1' }); + Object.defineProperty(process, 'platform', { ...descriptor, value: 'linux' }); + const sensitive = new EnvironmentMap({ A: '1' }); + expect(insensitive.equals(sensitive)).toBe(false); + expect(sensitive.equals(insensitive)).toBe(false); + } finally { + Object.defineProperty(process, 'platform', descriptor); + } + }); + }); + test('_sanityCheck() throws', () => { const map = new EnvironmentMap(); const environmentObject = { A: '123' }; diff --git a/libraries/rush-lib/src/logic/ProjectChangeAnalyzer.ts b/libraries/rush-lib/src/logic/ProjectChangeAnalyzer.ts index bb43f6b1311..7e75eab84f1 100644 --- a/libraries/rush-lib/src/logic/ProjectChangeAnalyzer.ts +++ b/libraries/rush-lib/src/logic/ProjectChangeAnalyzer.ts @@ -14,6 +14,7 @@ import { Sort, JsonFile, Objects, + EnvironmentMap, type IPackageJson } from '@rushstack/node-core-library'; import { @@ -496,7 +497,7 @@ export class ProjectChangeAnalyzer { const additionalHashes: Map = new Map( additionalFiles.size > 0 ? await hashFilesAsync(rootDirectory, additionalFiles, gitPath) : [] ); - const environment: Record = { ...process.env }; + const environment: EnvironmentMap = new EnvironmentMap(process.env); // The files that each operation depends on accumulate across snapshots const operationAdditionalFileCount: number = countOperationAdditionalFiles(projectMap); @@ -505,7 +506,7 @@ export class ProjectChangeAnalyzer { previousSnapshot.repoState === repoState && previousSnapshot.operationAdditionalFileCount === operationAdditionalFileCount && areMapsEqual(previousSnapshot.additionalHashes, additionalHashes) && - areEnvironmentsEqual(previousSnapshot.environment, environment) + previousSnapshot.environment.equals(environment) ) { // Every hash that a new snapshot would compute is the same. The previous snapshot began reading the // working tree earlier, which only widens the window in which a saved file may be newer than its hash. @@ -841,7 +842,7 @@ interface IAdditionalGlob { */ interface IReusableInputsSnapshot { readonly additionalHashes: ReadonlyMap; - readonly environment: Readonly>; + readonly environment: EnvironmentMap; readonly operationAdditionalFileCount: number; readonly repoState: IDetailedRepoState; readonly snapshot: InputsSnapshot; @@ -896,13 +897,6 @@ function areMapsEqual(a: ReadonlyMap, b: ReadonlyMap>, - b: Readonly> -): boolean { - return areMapsEqual(new Map(Object.entries(a)), new Map(Object.entries(b))); -} - async function getAdditionalFilesFromRushProjectConfigurationAsync( additionalGlobs: IAdditionalGlob[], rootRelativeLookupByPath: IReadonlyLookupByPath, diff --git a/libraries/rush-lib/src/logic/incremental/InputsSnapshot.ts b/libraries/rush-lib/src/logic/incremental/InputsSnapshot.ts index ad96a3e9007..587d17c83f1 100644 --- a/libraries/rush-lib/src/logic/incremental/InputsSnapshot.ts +++ b/libraries/rush-lib/src/logic/incremental/InputsSnapshot.ts @@ -7,7 +7,7 @@ import { createHash, type Hash } from 'node:crypto'; import ignore, { type Ignore } from 'ignore'; import { type IReadonlyLookupByPath, LookupByPath } from '@rushstack/lookup-by-path'; -import { InternalError, Path, Sort } from '@rushstack/node-core-library'; +import { EnvironmentMap, InternalError, Path, Sort } from '@rushstack/node-core-library'; import type { RushConfigurationProject } from '../../api/RushConfigurationProject'; import type { @@ -90,10 +90,10 @@ export interface IInputsSnapshotParameters { */ additionalHashes?: ReadonlyMap; /** - * The environment to use for `dependsOnEnvVars`. By default performs a snapshot of process.env upon construction. - * @defaultValue \{ ...process.env \} + * The environment for `dependsOnEnvVars`. The caller must not modify it after construction. + * @defaultValue new EnvironmentMap(process.env) */ - environment?: Record; + environment?: EnvironmentMap; /** * The Node.js version string to use for `dependsOnNodeVersion`. Defaults to `process.version`. * @defaultValue process.version @@ -251,7 +251,7 @@ export class InputsSnapshot implements IInputsSnapshot { /** * The environment to use for `dependsOnEnvVars`. */ - readonly #environment: Record; + readonly #environment: EnvironmentMap; /** * Pre-computed Node.js version strings at each granularity level for `dependsOnNodeVersion`. */ @@ -272,7 +272,7 @@ export class InputsSnapshot implements IInputsSnapshot { public constructor(params: IInputsSnapshotParameters) { const { additionalHashes, - environment = { ...process.env }, + environment = new EnvironmentMap(process.env), globalAdditionalFiles, hashes, hasUncommittedChanges, @@ -307,18 +307,16 @@ export class InputsSnapshot implements IInputsSnapshot { const operationAdditionalFileCount: number = countOperationAdditionalFiles(projectMap); this.#projectMetadataMap = - (previousSnapshot && - previousSnapshot.#tryDeriveProjectMetadataMap( - params, - environment, - nodeVersion, - globalAdditionalHashes, - operationAdditionalFileCount - )) ?? - createProjectMetadataMap(hashes, lookupByPath, projectMap, rootDir); + this.#tryDeriveProjectMetadataMap( + previousSnapshot, + params, + environment, + nodeVersion, + globalAdditionalHashes, + operationAdditionalFileCount + ) ?? createProjectMetadataMap(hashes, lookupByPath, projectMap, rootDir); this.#additionalHashes = additionalHashes; this.#globalAdditionalHashes = globalAdditionalHashes; - // Snapshot the environment so that queries are not impacted by when they happen this.#environment = environment; // Parse Node.js version once so it doesn't need to be re-parsed per operation this.#nodeVersionByGranularity = _parseNodeVersion(nodeVersion); @@ -427,15 +425,22 @@ export class InputsSnapshot implements IInputsSnapshot { const operationSettings: Readonly | undefined = operationName ? record.projectConfig?.operationSettingsByOperationName.get(operationName) : undefined; - const snapshotEnvironment: Readonly> = this.#environment; - if ( - environment && - operationSettings?.dependsOnEnvVars?.some( - (envVar: string) => (environment[envVar] || '') !== (snapshotEnvironment[envVar] || '') - ) - ) { - // The operation's environment differs from the snapshot's in a variable that it hashes, so don't memoize. - return this.#computeOperationOwnStateHash(project, operationName, operationSettings, environment); + const snapshotEnvironment: EnvironmentMap = this.#environment; + if (environment && operationSettings?.dependsOnEnvVars?.length) { + const operationEnvironment: EnvironmentMap = new EnvironmentMap(environment); + if ( + operationSettings.dependsOnEnvVars.some( + (envVar: string) => operationEnvironment.get(envVar) !== snapshotEnvironment.get(envVar) + ) + ) { + // The operation's environment differs in a variable that it hashes, so don't memoize. + return this.#computeOperationOwnStateHash( + project, + operationName, + operationSettings, + operationEnvironment + ); + } } const { hashByOperationName } = record; @@ -457,7 +462,7 @@ export class InputsSnapshot implements IInputsSnapshot { project: IRushConfigurationProjectForSnapshot, operationName: string | undefined, operationSettings: Readonly | undefined, - environment: Readonly> + environment: EnvironmentMap ): string { const hashes: ReadonlyMap = this.getTrackedFileHashesForOperation(project, operationName); @@ -465,11 +470,13 @@ export class InputsSnapshot implements IInputsSnapshot { // If this is for a specific operation, apply operation-specific options if (operationSettings) { const { dependsOnEnvVars, dependsOnNodeVersion, outputFolderNames } = operationSettings; - if (dependsOnEnvVars) { + if (dependsOnEnvVars?.length) { + // Earlier hashes start with hashDelimiter (or are empty). Keep this encoding in a distinct namespace. + hasher.update('env-v2\0'); // As long as we enumerate environment variables in a consistent order, we will get a stable hash. // Changing the order in rush-project.json will change the hash anyway since the file contents are part of the hash. for (const envVar of dependsOnEnvVars) { - hasher.update(`${hashDelimiter}$${envVar}=${environment[envVar] || ''}`); + hasher.update(`${hashDelimiter}$${JSON.stringify([envVar, environment.get(envVar)])}`); } } @@ -506,38 +513,46 @@ export class InputsSnapshot implements IInputsSnapshot { } /** - * Returns the state of each project for a later snapshot with the given parameters. It is the state of each - * project in this snapshot whose inputs have the same hashes, and new state for each other project. Returns - * undefined if the later snapshot differs from this one in more than the hashes of files. + * Reuses the state of projects whose input hashes are unchanged. Returns undefined if there is no previous + * snapshot or it differs in more than file hashes. */ #tryDeriveProjectMetadataMap( + previousSnapshot: InputsSnapshot | undefined, params: IInputsSnapshotParameters, - environment: Readonly>, + environment: EnvironmentMap, nodeVersion: string, globalAdditionalHashes: ReadonlyMap | undefined, operationAdditionalFileCount: number ): Map | undefined { const { additionalHashes, hashes, lookupByPath, projectMap, rootDir } = params; if ( - lookupByPath !== this.#lookupByPath || - projectMap !== this.#projectMap || - rootDir !== this.rootDirectory || - nodeVersion !== this.#nodeVersion || - operationAdditionalFileCount !== this.#operationAdditionalFileCount || - !areMapsEqual(globalAdditionalHashes ?? EMPTY_MAP, this.#globalAdditionalHashes ?? EMPTY_MAP) || - !areEnvironmentsEqual(environment, this.#environment) + !previousSnapshot || + lookupByPath !== previousSnapshot.#lookupByPath || + projectMap !== previousSnapshot.#projectMap || + rootDir !== previousSnapshot.rootDirectory || + nodeVersion !== previousSnapshot.#nodeVersion || + operationAdditionalFileCount !== previousSnapshot.#operationAdditionalFileCount || + !areMapsEqual( + globalAdditionalHashes ?? EMPTY_MAP, + previousSnapshot.#globalAdditionalHashes ?? EMPTY_MAP + ) || + !environment.equals(previousSnapshot.#environment) ) { return undefined; } const changedFiles: Set = new Set(); - addChangedFiles(this.hashes, hashes, changedFiles); - addChangedFiles(this.#additionalHashes ?? EMPTY_MAP, additionalHashes ?? EMPTY_MAP, changedFiles); + addChangedFiles(previousSnapshot.hashes, hashes, changedFiles); + addChangedFiles( + previousSnapshot.#additionalHashes ?? EMPTY_MAP, + additionalHashes ?? EMPTY_MAP, + changedFiles + ); const previousMetadataMap: ReadonlyMap< IRushConfigurationProjectForSnapshot, IInternalInputsSnapshotProjectMetadata - > = this.#projectMetadataMap; + > = previousSnapshot.#projectMetadataMap; const projectMetadataMap: Map< IRushConfigurationProjectForSnapshot, IInternalInputsSnapshotProjectMetadata @@ -748,24 +763,6 @@ function areMapsEqual(a: ReadonlyMap, b: ReadonlyMap>, - b: Readonly> -): boolean { - const keys: string[] = Object.keys(a); - if (keys.length !== Object.keys(b).length) { - return false; - } - - for (const key of keys) { - if (a[key] !== b[key] || !Object.prototype.hasOwnProperty.call(b, key)) { - return false; - } - } - - return true; -} - /** * Parses a Node.js version string once and returns pre-computed strings for each granularity level. * diff --git a/libraries/rush-lib/src/logic/incremental/test/InputsSnapshot.test.ts b/libraries/rush-lib/src/logic/incremental/test/InputsSnapshot.test.ts index fc29aaa8487..8689d6f8639 100644 --- a/libraries/rush-lib/src/logic/incremental/test/InputsSnapshot.test.ts +++ b/libraries/rush-lib/src/logic/incremental/test/InputsSnapshot.test.ts @@ -2,6 +2,8 @@ // See LICENSE in the project root for license information. import { LookupByPath } from '@rushstack/lookup-by-path'; +import { EnvironmentMap } from '@rushstack/node-core-library'; +import { createHash } from 'node:crypto'; import type { RushProjectConfiguration } from '../../../api/RushProjectConfiguration'; import { @@ -10,6 +12,7 @@ import { type IInputsSnapshotProjectMetadata, type IRushConfigurationProjectForSnapshot } from '../InputsSnapshot'; +import { RushConstants } from '../../RushConstants'; describe(InputsSnapshot.name, () => { function getTestConfig(): { @@ -730,7 +733,7 @@ describe(InputsSnapshot.name, () => { } ] ]), - environment: {} + environment: new EnvironmentMap() }); const result1: string = input1.getOperationOwnStateHash(project, '_phase:build'); @@ -748,7 +751,7 @@ describe(InputsSnapshot.name, () => { } ] ]), - environment: { ENV_VAR: 'some_value' } + environment: new EnvironmentMap({ ENV_VAR: 'some_value' }) }); const result2: string = input2.getOperationOwnStateHash(project, '_phase:build'); @@ -769,7 +772,7 @@ describe(InputsSnapshot.name, () => { new InputsSnapshot({ ...options, projectMap: new Map([[project, { projectConfig: projectConfig as RushProjectConfiguration }]]), - environment + environment: new EnvironmentMap(environment) }); const snapshotA: InputsSnapshot = createSnapshot({ ENV_VAR: 'a', OTHER: 'a' }); const snapshotB: InputsSnapshot = createSnapshot({ ENV_VAR: 'b' }); @@ -795,6 +798,128 @@ describe(InputsSnapshot.name, () => { }); }); + describe('declared environment cache identity', () => { + function createSnapshot( + environment: Record, + dependsOnEnvVars: string[] = ['ENV_VAR'] + ): ReturnType { + const { project, options } = getTestConfig(); + const projectConfig: Pick = { + operationSettingsByOperationName: new Map([ + ['_phase:build', { operationName: '_phase:build', dependsOnEnvVars }] + ]) + }; + return { + project, + input: new InputsSnapshot({ + ...options, + environment: new EnvironmentMap(environment), + projectMap: new Map([[project, { projectConfig: projectConfig as RushProjectConfiguration }]]) + }) + }; + } + + describe.each([false, true])('with an explicit operation environment: %s', (explicit) => { + function getHash(environment: Record, names?: string[]): string { + const { project, input } = createSnapshot(explicit ? { ENV_VAR: 'snapshot' } : environment, names); + return input.getOperationOwnStateHash(project, '_phase:build', explicit ? environment : undefined); + } + + it('does not reuse cached output when an empty value overrides a default', () => { + const render = (environment: Record): string => + JSON.stringify({ publicPath: environment.ENV_VAR ?? '/default/' }); + const absent: Record = {}; + const empty: Record = { ENV_VAR: '' }; + const cache: Map = new Map([[getHash(absent), render(absent)]]); + expect(render(absent)).not.toBe(render(empty)); + expect(cache.has(getHash(empty))).toBe(false); + cache.set(getHash(empty), render(empty)); + expect(cache.get(getHash(absent))).toBe('{"publicPath":"/default/"}'); + expect(cache.get(getHash(empty))).toBe('{"publicPath":""}'); + }); + + it('distinguishes unset, empty and literal sentinel values', () => { + const values: Array = [undefined, '', 'undefined', 'null', 'value']; + expect(new Set(values.map((value) => getHash({ ENV_VAR: value }))).size).toBe(values.length); + expect(getHash({})).toBe(getHash({ ENV_VAR: undefined })); + }); + + it.each(['win32', 'linux'])( + 'uses %s environment-name lookup without changing declarations', + (platform) => { + const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(process, 'platform')!; + Object.defineProperty(process, 'platform', { ...descriptor, value: platform }); + try { + const upper: string = getHash({ ENV_VAR: 'first' }); + const lower: string = getHash({ env_var: 'first' }); + expect(lower === upper).toBe(platform === 'win32'); + expect(lower === getHash({ env_var: 'second' })).toBe(platform !== 'win32'); + if (platform !== 'win32') { + expect(lower).toBe(getHash({})); + } + } finally { + Object.defineProperty(process, 'platform', descriptor); + } + } + ); + + it('excludes undeclared values and disambiguates embedded separators', () => { + expect(getHash({ ENV_VAR: 'same', OTHER: 'first' })).toBe( + getHash({ ENV_VAR: 'same', OTHER: 'second' }) + ); + const delimiter: string = RushConstants.hashDelimiter; + const names: string[] = ['A', 'B']; + const first = { A: `a${delimiter}$B=b`, B: 'c' }; + const second = { A: 'a', B: `b${delimiter}$B=c` }; + const legacyEncoding = (environment: Record): string => + names.map((name) => `${delimiter}$${name}=${environment[name] || ''}`).join(''); + expect(legacyEncoding(first)).toBe(legacyEncoding(second)); + expect(getHash(first, names)).not.toBe(getHash(second, names)); + }); + }); + + it('does not reuse the previous encoding for any tested environment value', () => { + const values: Array = [undefined, '', 'undefined', 'null', 'a|$ENV_VAR=b', '"\\']; + const oldHashes: Set = new Set(); + const newHashes: Set = new Set(); + for (const value of values) { + const { input, project } = createSnapshot({ ENV_VAR: value }); + const hasher = createHash('sha1'); + hasher.update(`${RushConstants.hashDelimiter}$ENV_VAR=${value || ''}`); + for (const [file, hash] of input.getTrackedFileHashesForOperation(project, '_phase:build')) { + hasher.update(`${RushConstants.hashDelimiter}${file}${RushConstants.hashDelimiter}${hash}`); + } + oldHashes.add(hasher.digest('hex')); + newHashes.add(input.getOperationOwnStateHash(project, '_phase:build')); + } + expect([...newHashes].some((hash) => oldHashes.has(hash))).toBe(false); + }); + + it('preserves hashes when no environment variables are declared', () => { + const { project, input } = getTrivialSnapshot(); + const { project: emptyProject, input: empty } = createSnapshot({ ENV_VAR: 'ignored' }, []); + expect(empty.getOperationOwnStateHash(emptyProject, '_phase:build', { ENV_VAR: 'different' })).toBe( + input.getOperationOwnStateHash(project, '_phase:build') + ); + }); + + it.each([undefined, ''])('isolates an explicit unset/empty override from memoization (%s)', (value) => { + const { project, input } = createSnapshot({ ENV_VAR: value }); + const operationEnvironment = { ENV_VAR: value === undefined ? '' : undefined }; + const { project: otherProject, input: other } = createSnapshot(operationEnvironment); + const operationHash: string = other.getOperationOwnStateHash(otherProject, '_phase:build'); + expect(input.getOperationOwnStateHash(project, '_phase:build', operationEnvironment)).toBe( + operationHash + ); + const snapshotHash: string = input.getOperationOwnStateHash(project, '_phase:build'); + expect(snapshotHash).not.toBe(operationHash); + expect(input.getOperationOwnStateHash(project, '_phase:build', operationEnvironment)).toBe( + operationHash + ); + expect(input.getOperationOwnStateHash(project, '_phase:build')).toBe(snapshotHash); + }); + }); + describe('previousSnapshot', () => { const operationNames: (string | undefined)[] = [undefined, '_phase:build', '_phase:test']; @@ -854,7 +979,7 @@ describe(InputsSnapshot.name, () => { options: { rootDir: '/root', additionalHashes: new Map([['/ext/tool.json', 'ext1']]), - environment: { FOO: '1' }, + environment: new EnvironmentMap({ FOO: '1' }), globalAdditionalFiles: ['common/config/global.json'], hashes: new Map([ ['a/README.md', 'a0'], @@ -920,6 +1045,51 @@ describe(InputsSnapshot.name, () => { expect(derived.workingTreeReadStartTimeMs).toBe(options.workingTreeReadStartTimeMs); } + it.each([undefined, ''])('invalidates reuse for unset/empty changes (%s)', (value) => { + const { options, a, projects } = getDerivationTestConfig(); + const previousSnapshot: InputsSnapshot = new InputsSnapshot({ + ...options, + environment: new EnvironmentMap({ FOO: value }) + }); + const before: string = previousSnapshot.getOperationOwnStateHash(a, '_phase:build'); + const nextOptions: IInputsSnapshotParameters = { + ...options, + environment: new EnvironmentMap({ FOO: value === undefined ? '' : undefined }), + previousSnapshot + }; + const next: InputsSnapshot = new InputsSnapshot(nextOptions); + expect(next.getOperationOwnStateHash(a, '_phase:build')).not.toBe(before); + expectSameAsNewSnapshot(next, nextOptions, projects); + }); + + it.each(['win32', 'linux'])('uses %s environment comparison when deriving a snapshot', (platform) => { + const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(process, 'platform')!; + Object.defineProperty(process, 'platform', { ...descriptor, value: platform }); + try { + const { options, a, projects } = getDerivationTestConfig(); + const previousSnapshot: InputsSnapshot = new InputsSnapshot(options); + const previousFiles = previousSnapshot.getTrackedFileHashesForOperation(a, '_phase:build'); + queryAll(previousSnapshot, projects); + const nextOptions: IInputsSnapshotParameters = { + ...options, + environment: new EnvironmentMap({ foo: '1' }), + previousSnapshot + }; + const next: InputsSnapshot = new InputsSnapshot(nextOptions); + expect(next.getTrackedFileHashesForOperation(a, '_phase:build') === previousFiles).toBe( + platform === 'win32' + ); + expectSameAsNewSnapshot(next, nextOptions, projects); + const changedOptions: IInputsSnapshotParameters = { + ...nextOptions, + environment: new EnvironmentMap({ foo: '2' }) + }; + expectSameAsNewSnapshot(new InputsSnapshot(changedOptions), changedOptions, projects); + } finally { + Object.defineProperty(process, 'platform', descriptor); + } + }); + it('Reuses the state of each project whose inputs did not change', () => { const { projects, a, b, options } = getDerivationTestConfig(); const previousSnapshot: InputsSnapshot = new InputsSnapshot(options); @@ -1024,8 +1194,11 @@ describe(InputsSnapshot.name, () => { const hashes: Map = new Map(options.hashes); hashes.set('a/src/x.ts', 'a1-changed'); const changes: [string, () => Partial][] = [ - ['environment', () => ({ environment: { FOO: '2' } })], - ['an environment variable that no operation hashes', () => ({ environment: { FOO: '1', BAR: '' } })], + ['environment', () => ({ environment: new EnvironmentMap({ FOO: '2' }) })], + [ + 'an environment variable that no operation hashes', + () => ({ environment: new EnvironmentMap({ FOO: '1', BAR: '' }) }) + ], ['node version', () => ({ nodeVersion: 'v23.0.0' })], [ 'global additional file', diff --git a/libraries/rush-lib/src/logic/incremental/test/__snapshots__/InputsSnapshot.test.ts.snap b/libraries/rush-lib/src/logic/incremental/test/__snapshots__/InputsSnapshot.test.ts.snap index f8dcd553d3f..91b3e542ffb 100644 --- a/libraries/rush-lib/src/logic/incremental/test/__snapshots__/InputsSnapshot.test.ts.snap +++ b/libraries/rush-lib/src/logic/incremental/test/__snapshots__/InputsSnapshot.test.ts.snap @@ -6,9 +6,9 @@ exports[`InputsSnapshot getOperationOwnStateHash Handles trivial input 1`] = `"a exports[`InputsSnapshot getOperationOwnStateHash Respects additionalOutputFilesByOperationName 1`] = `"07f4147294d21a07865de84875d60bfbcc690652"`; -exports[`InputsSnapshot getOperationOwnStateHash Respects dependsOnEnvVars 1`] = `"ad1f915d0ac6331c09febbbe1496c970a5401b73"`; +exports[`InputsSnapshot getOperationOwnStateHash Respects dependsOnEnvVars 1`] = `"980bd656afb55515b53be36f9d9ea7aaebfaa76e"`; -exports[`InputsSnapshot getOperationOwnStateHash Respects dependsOnEnvVars 2`] = `"2c68d56fc9278b6495496070a6a992b929c37a83"`; +exports[`InputsSnapshot getOperationOwnStateHash Respects dependsOnEnvVars 2`] = `"00211b6f51668d85598e5ca390fd2e6a630a103b"`; exports[`InputsSnapshot getOperationOwnStateHash Respects dependsOnNodeVersion 1`] = `"cc182bde6aa81c0410ede7db22f3af2f0a24d3e3"`; diff --git a/libraries/rush-lib/src/logic/operations/test/IncrementalExecutionGuardPlugin.test.ts b/libraries/rush-lib/src/logic/operations/test/IncrementalExecutionGuardPlugin.test.ts index e6ea0d51c65..c4b62f6f1b4 100644 --- a/libraries/rush-lib/src/logic/operations/test/IncrementalExecutionGuardPlugin.test.ts +++ b/libraries/rush-lib/src/logic/operations/test/IncrementalExecutionGuardPlugin.test.ts @@ -55,7 +55,7 @@ import * as path from 'node:path'; import { PassThrough } from 'node:stream'; import { LookupByPath } from '@rushstack/lookup-by-path'; -import { Executable, SubprocessTerminator } from '@rushstack/node-core-library'; +import { EnvironmentMap, Executable, SubprocessTerminator } from '@rushstack/node-core-library'; import { type ITerminal, MockWritable, StringBufferTerminalProvider, Terminal } from '@rushstack/terminal'; import type { IPhase } from '../../../api/CommandLineConfiguration'; @@ -657,7 +657,7 @@ async function createWorkspaceAsync( hasUncommittedChanges: false, lookupByPath, projectMap, - environment: { ...environment }, + environment: new EnvironmentMap(environment), workingTreeReadStartTimeMs: startTimeMs }); }; diff --git a/libraries/rush-lib/src/logic/test/ProjectChangeAnalyzer.test.ts b/libraries/rush-lib/src/logic/test/ProjectChangeAnalyzer.test.ts index 28f922e1754..2408765621b 100644 --- a/libraries/rush-lib/src/logic/test/ProjectChangeAnalyzer.test.ts +++ b/libraries/rush-lib/src/logic/test/ProjectChangeAnalyzer.test.ts @@ -378,12 +378,12 @@ describe(ProjectChangeAnalyzer.name, () => { reuseOptions ); const snapshot: IInputsSnapshot | undefined = await provider!(); - expect(mockSnapshot.mock.calls[0][0].environment).toEqual(process.env); + expect(mockSnapshot.mock.calls[0][0].environment.toObject()).toEqual(process.env); process.env.PROJECT_CHANGE_ANALYZER_TEST = '1'; const nextSnapshot: IInputsSnapshot | undefined = await provider!(); expect(nextSnapshot).not.toBe(snapshot); - expect(mockSnapshot.mock.calls[1][0].environment).toEqual(process.env); + expect(mockSnapshot.mock.calls[1][0].environment.toObject()).toEqual(process.env); await expect(provider!()).resolves.toBe(nextSnapshot); process.env.PROJECT_CHANGE_ANALYZER_TEST = '2'; @@ -715,10 +715,7 @@ describe(ProjectChangeAnalyzer.name, () => { mockGetRepoChanges.mockReturnValue( new Map([ - [ - 'b/package.json', - { mode: 'modified', newhash: 'newhash-b', oldhash: 'oldhash-b', status: 'M' } - ] + ['b/package.json', { mode: 'modified', newhash: 'newhash-b', oldhash: 'oldhash-b', status: 'M' }] ]) ); const packageJsonByHash: Record = {