cdktn 0.25.0-pre.8 → 0.25.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (94) hide show
  1. package/.jsii +2194 -424
  2. package/README.md +12 -0
  3. package/lib/annotations.js +4 -4
  4. package/lib/app.js +54 -5
  5. package/lib/aspect.js +3 -4
  6. package/lib/asset-hash.d.ts +75 -0
  7. package/lib/asset-hash.js +129 -0
  8. package/lib/asset-staging.d.ts +180 -0
  9. package/lib/asset-staging.js +464 -0
  10. package/lib/assets.d.ts +401 -0
  11. package/lib/assets.js +333 -0
  12. package/lib/backends/azurerm-backend.js +4 -6
  13. package/lib/backends/cloud-backend.js +15 -12
  14. package/lib/backends/consul-backend.js +4 -6
  15. package/lib/backends/cos-backend.js +4 -6
  16. package/lib/backends/gcs-backend.js +4 -6
  17. package/lib/backends/http-backend.js +4 -6
  18. package/lib/backends/local-backend.js +38 -7
  19. package/lib/backends/oss-backend.js +4 -6
  20. package/lib/backends/pg-backend.js +4 -6
  21. package/lib/backends/remote-backend.js +8 -10
  22. package/lib/backends/s3-backend.js +4 -6
  23. package/lib/backends/swift-backend.js +4 -6
  24. package/lib/complex-computed-list.js +114 -65
  25. package/lib/errors.d.ts +16 -0
  26. package/lib/errors.js +51 -3
  27. package/lib/functions/provider-function.js +2 -4
  28. package/lib/functions/terraform-functions.generated.js +2 -4
  29. package/lib/ignore-strategy.d.ts +82 -0
  30. package/lib/ignore-strategy.js +29 -0
  31. package/lib/importable-resource.js +8 -6
  32. package/lib/index.d.ts +4 -0
  33. package/lib/index.js +28 -2
  34. package/lib/manifest.js +49 -11
  35. package/lib/private/fs.d.ts +74 -2
  36. package/lib/private/fs.js +129 -17
  37. package/lib/private/unique.js +35 -2
  38. package/lib/resource.js +3 -4
  39. package/lib/synthesize/synthesizer.js +51 -25
  40. package/lib/terraform-asset.d.ts +68 -5
  41. package/lib/terraform-asset.js +127 -40
  42. package/lib/terraform-backend.js +3 -4
  43. package/lib/terraform-count.js +3 -4
  44. package/lib/terraform-data-resource.d.ts +1 -1
  45. package/lib/terraform-data-resource.js +18 -13
  46. package/lib/terraform-data-source.js +10 -4
  47. package/lib/terraform-dynamic-block.js +5 -2
  48. package/lib/terraform-dynamic-expression.js +4 -1
  49. package/lib/terraform-element.js +34 -6
  50. package/lib/terraform-ephemeral-resource.js +10 -4
  51. package/lib/terraform-functions.js +2 -4
  52. package/lib/terraform-hcl-module.js +3 -4
  53. package/lib/terraform-iterator.js +11 -12
  54. package/lib/terraform-local.js +3 -4
  55. package/lib/terraform-module-asset.js +39 -4
  56. package/lib/terraform-module.js +8 -4
  57. package/lib/terraform-operators.js +2 -4
  58. package/lib/terraform-output.js +7 -4
  59. package/lib/terraform-provider.js +5 -4
  60. package/lib/terraform-provisioner.js +2 -4
  61. package/lib/terraform-remote-state.js +5 -5
  62. package/lib/terraform-resource-targets.js +3 -7
  63. package/lib/terraform-resource.js +23 -7
  64. package/lib/terraform-stack.js +38 -38
  65. package/lib/terraform-variable.js +25 -22
  66. package/lib/testing/adapters/jest.d.ts +2 -1
  67. package/lib/testing/adapters/jest.js +3 -3
  68. package/lib/testing/index.js +42 -8
  69. package/lib/testing/matchers.d.ts +34 -30
  70. package/lib/testing/matchers.js +329 -93
  71. package/lib/tfExpression.js +25 -8
  72. package/lib/tokens/lazy.js +11 -7
  73. package/lib/tokens/private/dependency.js +2 -2
  74. package/lib/tokens/private/encoding.js +6 -1
  75. package/lib/tokens/private/intrinsic.js +6 -1
  76. package/lib/tokens/private/resolve.js +2 -5
  77. package/lib/tokens/private/token-map.js +4 -6
  78. package/lib/tokens/private/uniqueid.js +35 -2
  79. package/lib/tokens/resolvable.js +4 -6
  80. package/lib/tokens/string-fragments.js +6 -10
  81. package/lib/tokens/token.js +15 -18
  82. package/lib/upgrade-id-aspect.js +37 -6
  83. package/lib/validations/index.d.ts +0 -1
  84. package/lib/validations/index.js +1 -2
  85. package/lib/validations/target-versions.js +39 -2
  86. package/lib/validations/validate-function-version-support.js +2 -1
  87. package/lib/validations/validate-provider-function-target-support.js +2 -1
  88. package/lib/validations/validate-provider-presence.js +10 -9
  89. package/package.json +21 -7
  90. package/scripts/pack.mjs +27 -12
  91. package/lib/validations/validate-binary-version.d.ts +0 -23
  92. package/lib/validations/validate-binary-version.js +0 -54
  93. package/lib/validations/validate-terraform-version.d.ts +0 -13
  94. package/lib/validations/validate-terraform-version.js +0 -21
@@ -1,5 +1,37 @@
1
1
  "use strict";
2
- var _a;
2
+ var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
3
+ if (k2 === undefined) k2 = k;
4
+ var desc = Object.getOwnPropertyDescriptor(m, k);
5
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
6
+ desc = { enumerable: true, get: function() { return m[k]; } };
7
+ }
8
+ Object.defineProperty(o, k2, desc);
9
+ }) : (function(o, m, k, k2) {
10
+ if (k2 === undefined) k2 = k;
11
+ o[k2] = m[k];
12
+ }));
13
+ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
14
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
15
+ }) : function(o, v) {
16
+ o["default"] = v;
17
+ });
18
+ var __importStar = (this && this.__importStar) || (function () {
19
+ var ownKeys = function(o) {
20
+ ownKeys = Object.getOwnPropertyNames || function (o) {
21
+ var ar = [];
22
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
23
+ return ar;
24
+ };
25
+ return ownKeys(o);
26
+ };
27
+ return function (mod) {
28
+ if (mod && mod.__esModule) return mod;
29
+ var result = {};
30
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
31
+ __setModuleDefault(result, mod);
32
+ return result;
33
+ };
34
+ })();
3
35
  Object.defineProperty(exports, "__esModule", { value: true });
4
36
  exports.AssertionReturn = void 0;
5
37
  exports.returnMatcherToJest = returnMatcherToJest;
@@ -7,37 +39,34 @@ exports.asymetricDeepEqualIgnoringObjectCasing = asymetricDeepEqualIgnoringObjec
7
39
  exports.getToHaveDataSourceWithProperties = getToHaveDataSourceWithProperties;
8
40
  exports.getToHaveResourceWithProperties = getToHaveResourceWithProperties;
9
41
  exports.getToHaveProviderWithProperties = getToHaveProviderWithProperties;
42
+ exports.warmUpProviderLockFileCache = warmUpProviderLockFileCache;
10
43
  exports.toBeValidTerraform = toBeValidTerraform;
11
44
  exports.toPlanSuccessfully = toPlanSuccessfully;
12
45
  const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
13
46
  // Copyright (c) HashiCorp, Inc
14
47
  // SPDX-License-Identifier: MPL-2.0
15
- const fs = require("fs");
16
- const path = require("path");
48
+ const fs = __importStar(require("fs"));
49
+ const os = __importStar(require("os"));
50
+ const path = __importStar(require("path"));
51
+ const crypto = __importStar(require("crypto"));
17
52
  const child_process_1 = require("child_process");
18
53
  const util_1 = require("../util");
19
54
  const errors_1 = require("../errors");
20
55
  /**
21
- * Class representing the contents of a return by an assertion
56
+ * The result of a testing matcher assertion.
22
57
  */
23
58
  class AssertionReturn {
24
- /**
25
- * Create an AssertionReturn
26
- * @param message - String message containing information about the result of the assertion
27
- * @param pass - Boolean pass denoting the success of the assertion
28
- */
59
+ message;
60
+ pass;
61
+ static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.testingMatchers.AssertionReturn", version: "0.25.0" };
29
62
  constructor(message, pass) {
30
63
  this.message = message;
31
64
  this.pass = pass;
32
65
  }
33
66
  }
34
67
  exports.AssertionReturn = AssertionReturn;
35
- _a = JSII_RTTI_SYMBOL_1;
36
- AssertionReturn[_a] = { fqn: "cdktn.testingMatchers.AssertionReturn", version: "0.25.0-pre.8" };
37
68
  /**
38
- * Reformats the contents of the base testing matcher return type AssertionReturn into type useable by jest
39
- * @param toReturn
40
- * @returns {MatcherReturnJest}
69
+ * Adapts an {@link AssertionReturn} to Jest's `{ message, pass }` matcher shape.
41
70
  */
42
71
  function returnMatcherToJest(toReturn) {
43
72
  return {
@@ -46,11 +75,8 @@ function returnMatcherToJest(toReturn) {
46
75
  };
47
76
  }
48
77
  /**
49
- * Compares expected and received. All expected properties are matched and considered equal even if
50
- * there are more properties in the received object than in the expected object in which case it will still return true.
51
- * @param expected
52
- * @param received
53
- * @returns {boolean}
78
+ * Deep-equals `expected` against `received`, ignoring extra properties on `received` and
79
+ * matching each key in either camelCase or snake_case.
54
80
  */
55
81
  function asymetricDeepEqualIgnoringObjectCasing(expected, received) {
56
82
  switch (typeof expected) {
@@ -69,7 +95,6 @@ function asymetricDeepEqualIgnoringObjectCasing(expected, received) {
69
95
  if (expected === null || received === null) {
70
96
  return false;
71
97
  }
72
- // recursively compare objects and allow snake case as well as camel case
73
98
  return Object.keys(expected).every((key) => {
74
99
  if (received[key] !== undefined) {
75
100
  return asymetricDeepEqualIgnoringObjectCasing(expected[key], received[key]);
@@ -90,21 +115,20 @@ const defaultPassEvaluation = (items, assertedProperties) => {
90
115
  function isAsymmetric(obj) {
91
116
  return !!obj && typeof obj === "object" && "asymmetricMatch" in obj;
92
117
  }
93
- // You can use expect.Anything(), expect.ObjectContaining, etc in jest, this makes it nicer to read
94
- // when we print error messages
118
+ // Renders jest asymmetric matchers (expect.anything(), etc.) as "expect.Anything()" in messages,
119
+ // instead of their internal object representation.
95
120
  // eslint-disable-next-line jsdoc/require-jsdoc
96
121
  function jestAsymetricMatcherStringifyReplacer(_key, value) {
97
122
  return isAsymmetric(value) ? `expect.${value.toString()}` : value;
98
123
  }
99
124
  // eslint-disable-next-line jsdoc/require-jsdoc
100
125
  function getAssertElementWithProperties(functionName,
101
- // We have the evaluation function configurable so we can make use of the specific testing frameworks capabilities
102
- // This makes the resulting tests more native to the testing framework
126
+ // Configurable so each adapter (Jest, Vitest, ...) can use its own matcher semantics.
103
127
  customPassEvaluation) {
104
128
  const passEvaluation = customPassEvaluation || defaultPassEvaluation;
105
129
  return function getAssertElementWithProperties(type, received, itemType, properties = {}) {
106
130
  let stack;
107
- // Rececived could either be a JSON string or a path to a file
131
+ // received may be a JSON string or a path to a file containing one
108
132
  const stackContent = fs.existsSync(received)
109
133
  ? fs.readFileSync(received, "utf8")
110
134
  : received;
@@ -114,10 +138,8 @@ customPassEvaluation) {
114
138
  catch (e) {
115
139
  throw (0, errors_1.invalidStack)(functionName, stackContent);
116
140
  }
117
- const items = Object.values(Object.entries(stack[type] || {}) // for all data/resource entries
118
- .find(
119
- // find the object with a matching name
120
- ([type, _values]) => type === itemType.tfResourceType)?.[1] || {}) || []; // get a list of all configs of that type
141
+ // find every item of itemType.tfResourceType under stack[type], keyed by name
142
+ const items = Object.values(Object.entries(stack[type] || {}).find(([type, _values]) => type === itemType.tfResourceType)?.[1] || {}) || [];
121
143
  const pass = passEvaluation(items, properties);
122
144
  if (pass) {
123
145
  return new AssertionReturn(`Expected no ${itemType.tfResourceType} with properties ${JSON.stringify(properties, jestAsymetricMatcherStringifyReplacer)} to be present in synthesized stack.
@@ -130,88 +152,269 @@ Found ${items.length === 0 ? "no" : items.length} ${itemType.tfResourceType} res
130
152
  };
131
153
  }
132
154
  /**
133
- * Returns the function toHaveDataSourceWithProperties using the evaluation properties of customPassEvaluation
134
- * @param customPassEvaluation
135
- * @returns {getToHaveDataSourceWithProperties~toHaveDataSourceWithProperties}
155
+ * Returns a `toHaveDataSourceWithProperties` matcher using `customPassEvaluation` to decide a
156
+ * match.
136
157
  */
137
158
  function getToHaveDataSourceWithProperties(customPassEvaluation) {
138
- /**
139
- * Evaluates the received stack to have the data source resourceType containing specified properties
140
- * @param received
141
- * @param resourceType
142
- * @param properties
143
- * @returns {AssertionReturn}
144
- */
145
159
  return function toHaveDataSourceWithProperties(received, resourceType, properties = {}) {
146
160
  return getAssertElementWithProperties("toHaveDataSourceWithProperties", customPassEvaluation)("data", received, resourceType, properties);
147
161
  };
148
162
  }
149
163
  /**
150
- * Returns the function toHaveResourceWithProperties using the evaluation properties of customPassEvaluation
151
- * @param customPassEvaluation
152
- * @returns
164
+ * Returns a `toHaveResourceWithProperties` matcher using `customPassEvaluation` to decide a
165
+ * match.
153
166
  */
154
167
  function getToHaveResourceWithProperties(customPassEvaluation) {
155
- /**
156
- * Evaluates the received stack to have the resource resourceType containing specified properties
157
- * @param received
158
- * @param resourceType
159
- * @param properties
160
- * @returns {AssertionReturn}
161
- */
162
168
  return function toHaveResourceWithProperties(received, resourceType, properties = {}) {
163
169
  return getAssertElementWithProperties("toHaveResourceWithProperties", customPassEvaluation)("resource", received, resourceType, properties);
164
170
  };
165
171
  }
166
172
  /**
167
- * A helper util to verify wether an Error was caused by the Nodejs `process.spawn` API.
168
- *
169
- * @param {Error} err The Error object to verify
170
- * @returns {Boolean} A bool indicating wether the input Error is containing process.spawn output.
173
+ * Reports whether `err` carries `child_process.execSync`/`spawnSync` output buffers.
171
174
  */
172
175
  const isExecSpawnError = (err) => "output" in err &&
173
176
  Array.isArray(err.output) &&
174
177
  err.output.some((buf) => Buffer.isBuffer(buf));
175
178
  /**
176
- * A helper util to append `process.spawn` output to assertion messages to improve developer expirience.
177
- *
178
- * @param {String} message The message to optionally append process output to.
179
- * @param {Error} err The error from which the `process.spawn` output should be retreived from.
180
- * @returns {String} The finalized assertion message decorated with the `process.spawn` output.
179
+ * Renders terraform diagnostic entries as human-readable text.
180
+ */
181
+ const formatDiagnostics = (diagnostics) => diagnostics
182
+ .filter((d) => d?.severity && d?.summary)
183
+ .map(({ severity, summary, detail }) => `${severity}: ${summary}${detail ? `\n${detail}` : ""}`)
184
+ .join("\n");
185
+ /**
186
+ * Renders the diagnostics found in the output of a `terraform <cmd> -json` invocation as
187
+ * human-readable text. Handles both `plan`'s newline-delimited JSON stream (one `diagnostic`
188
+ * entry per line) and `validate`'s single pretty-printed object (a top-level `diagnostics`
189
+ * array).
190
+ */
191
+ const renderJsonDiagnostics = (output) => {
192
+ try {
193
+ const parsed = JSON.parse(output);
194
+ if (Array.isArray(parsed?.diagnostics)) {
195
+ return formatDiagnostics(parsed.diagnostics);
196
+ }
197
+ }
198
+ catch {
199
+ // not a single JSON object; fall through to the newline-delimited format
200
+ }
201
+ const diagnostics = output
202
+ .split("\n")
203
+ .map((line) => {
204
+ try {
205
+ return JSON.parse(line);
206
+ }
207
+ catch {
208
+ return undefined;
209
+ }
210
+ })
211
+ .filter((entry) => entry?.type === "diagnostic" && entry.diagnostic)
212
+ .map((entry) => entry.diagnostic);
213
+ return formatDiagnostics(diagnostics);
214
+ };
215
+ /**
216
+ * Appends a failed process's output to an assertion message, preferring rendered `-json`
217
+ * diagnostics over the raw output when available.
181
218
  */
182
219
  const withProcessOutput = (message, err) => {
183
- let output = "";
184
- if (isExecSpawnError(err)) {
185
- output =
186
- err.output
187
- ?.map((buffer) => buffer?.toString("utf8"))
188
- .filter(Boolean)
189
- .join("\n") ?? "";
220
+ if (!isExecSpawnError(err)) {
221
+ return `${message}: ${err}.`;
190
222
  }
191
- const appendix = output.length ? `. Output: ${output}` : "";
223
+ const output = err.output
224
+ ?.map((buffer) => buffer?.toString("utf8"))
225
+ .filter(Boolean)
226
+ .join("\n") ?? "";
227
+ // Diagnostics are parsed from stdout alone: concatenating stderr (e.g. a CLI-config error)
228
+ // into the mix would break the single-object parse `-json` output relies on.
229
+ const diagnostics = renderJsonDiagnostics(err.stdout?.toString("utf8") ?? "");
230
+ const appendix = diagnostics.length
231
+ ? `. Diagnostics: ${diagnostics}`
232
+ : output.length
233
+ ? `. Output: ${output}`
234
+ : "";
192
235
  return `${message}: ${err}${appendix}.`;
193
236
  };
194
237
  /**
195
- * Returns the function toHaveProviderWithProperties using the evaluation properties of customPassEvaluation
196
- * @param customPassEvaluation
197
- * @returns {getToHaveProviderWithProperties~toHaveProviderWithProperties}
238
+ * Returns a `toHaveProviderWithProperties` matcher using `customPassEvaluation` to decide a
239
+ * match.
198
240
  */
199
241
  function getToHaveProviderWithProperties(customPassEvaluation) {
200
- /**
201
- * Evaluates the received stack to have the provider resourceType containing specified properties
202
- * @param received
203
- * @param resourceType
204
- * @param properties
205
- * @returns {AssertionReturn}
206
- */
207
242
  return function toHaveProviderWithProperties(received, resourceType, properties = {}) {
208
243
  return getAssertElementWithProperties("toHaveProviderWithProperties", customPassEvaluation)("provider", received, resourceType, properties);
209
244
  };
210
245
  }
211
246
  /**
212
- * Evaluates the validity of the received stack
213
- * @param received
214
- * @returns {AssertionReturn}
247
+ * The root directory the provider lock-file cache is written under. Overridable via
248
+ * `CDKTN_TESTING_LOCKFILE_CACHE_DIR` so tests can assert on what gets written to it instead of
249
+ * sharing the real machine-global cache, and so CI can point it at a directory persisted
250
+ * between jobs.
251
+ */
252
+ function getProviderLockFileCacheRoot() {
253
+ return (process.env.CDKTN_TESTING_LOCKFILE_CACHE_DIR ??
254
+ path.join(os.tmpdir(), "cdktn-testing-provider-lockfiles"));
255
+ }
256
+ // A loosely pinned requirement (e.g. "~> 5.0") shouldn't stay pinned to whichever version a
257
+ // machine first resolved forever, so the cache expires.
258
+ const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
259
+ const binaryVersionCache = new Map();
260
+ // eslint-disable-next-line jsdoc/require-jsdoc
261
+ function getBinaryVersion(binaryName, env) {
262
+ const cached = binaryVersionCache.get(binaryName);
263
+ if (cached) {
264
+ return cached;
265
+ }
266
+ let version = "unknown";
267
+ try {
268
+ version = (0, child_process_1.execSync)(`${binaryName} version`, { env, stdio: "pipe" })
269
+ .toString("utf8")
270
+ .split("\n")[0];
271
+ }
272
+ catch {
273
+ // only affects cache partitioning, so "unknown" is an acceptable fallback
274
+ }
275
+ binaryVersionCache.set(binaryName, version);
276
+ return version;
277
+ }
278
+ // eslint-disable-next-line jsdoc/require-jsdoc
279
+ function getProviderLockCacheDir(workingDir, binaryName, env) {
280
+ try {
281
+ const config = JSON.parse(fs.readFileSync(path.join(workingDir, "cdk.tf.json"), "utf8"));
282
+ const cacheKey = crypto
283
+ .createHash("sha256")
284
+ .update(binaryName)
285
+ .update(getBinaryVersion(binaryName, env))
286
+ .update(JSON.stringify(config?.terraform?.required_providers ?? {}))
287
+ .digest("hex");
288
+ return path.join(getProviderLockFileCacheRoot(), cacheKey);
289
+ }
290
+ catch {
291
+ return undefined;
292
+ }
293
+ }
294
+ // eslint-disable-next-line jsdoc/require-jsdoc
295
+ function isCachedLockFileFresh(cachedLockFile) {
296
+ try {
297
+ return Date.now() - fs.statSync(cachedLockFile).mtimeMs < CACHE_TTL_MS;
298
+ }
299
+ catch {
300
+ return false;
301
+ }
302
+ }
303
+ /**
304
+ * Copies a cached `.terraform.lock.hcl` into `workingDir` if `warmUpProviderLockFileCache` has
305
+ * already resolved one for its exact set of required providers, and it hasn't expired. Never
306
+ * runs `init` itself. A `workingDir` that already has its own lock file is left untouched —
307
+ * real stack directories keep a pinned one (`cli-core` reads it from there), and overwriting it
308
+ * with the cached one would silently swap its versions.
309
+ *
310
+ * @returns whether a lock file was seeded.
311
+ */
312
+ function seedFromWarmCache(workingDir, binaryName, env) {
313
+ const targetLockFile = path.join(workingDir, ".terraform.lock.hcl");
314
+ if (fs.existsSync(targetLockFile)) {
315
+ return false;
316
+ }
317
+ const cacheDir = getProviderLockCacheDir(workingDir, binaryName, env);
318
+ if (!cacheDir) {
319
+ return false;
320
+ }
321
+ const cachedLockFile = path.join(cacheDir, ".terraform.lock.hcl");
322
+ if (!isCachedLockFileFresh(cachedLockFile)) {
323
+ return false;
324
+ }
325
+ fs.copyFileSync(cachedLockFile, targetLockFile);
326
+ return true;
327
+ }
328
+ /**
329
+ * Removes `TF_PLUGIN_CACHE_DIR` from `env`. Without a seeded lock file, `init` resolves
330
+ * providers itself; against terraform >= 1.4 that re-downloads into the shared plugin cache
331
+ * even when it's warm, racing other concurrent `init`s
332
+ * (https://github.com/open-constructs/cdk-terrain/issues/452). Dropping the cache dir from the
333
+ * environment makes `init` resolve into the stack's own `.terraform` directory instead, so it
334
+ * can't race another worker's writes to the shared cache. This doesn't cover a `plugin_cache_dir`
335
+ * set in the user's CLI config file rather than the environment, and
336
+ * `warmUpProviderLockFileCache` is still expected to run once per machine at a time — two warm-ups
337
+ * racing a cold plugin cache would hit the same race this works around.
338
+ */
339
+ function withoutPluginCache(env) {
340
+ const { TF_PLUGIN_CACHE_DIR: _unused, ...rest } = env;
341
+ return rest;
342
+ }
343
+ /**
344
+ * Resolves and caches a `.terraform.lock.hcl` for the exact set of required providers in
345
+ * `workingDir`, running a real `init` against the shared plugin cache. Only ever called from
346
+ * `warmUpProviderLockFileCache`, which runs serially within a single process, so no cross-
347
+ * process lock is needed: it's the only writer to the cache.
348
+ *
349
+ * `init` always runs, even when a fresh cached lock file exists: the lock-file cache and
350
+ * `TF_PLUGIN_CACHE_DIR` have independent lifetimes, so a fresh lock doesn't guarantee the
351
+ * providers it pins are still sitting in the plugin cache. Seeding the cached lock first (when
352
+ * `workingDir` doesn't already have one of its own, and the cache hasn't expired) just lets
353
+ * that `init` take the verified-checksum path instead of resolving from scratch. A stale cache
354
+ * is left alone so `init` re-resolves it, otherwise a loosely pinned requirement (e.g. `~> 5.0`)
355
+ * would stay pinned to whatever version this cache entry first resolved, forever.
356
+ */
357
+ function resolveAndCacheProviderLockFile(workingDir, binaryName, env) {
358
+ const cacheDir = getProviderLockCacheDir(workingDir, binaryName, env);
359
+ if (!cacheDir) {
360
+ return;
361
+ }
362
+ const targetLockFile = path.join(workingDir, ".terraform.lock.hcl");
363
+ const cachedLockFile = path.join(cacheDir, ".terraform.lock.hcl");
364
+ const hadOwnLockFile = fs.existsSync(targetLockFile);
365
+ if (!hadOwnLockFile && isCachedLockFileFresh(cachedLockFile)) {
366
+ try {
367
+ fs.copyFileSync(cachedLockFile, targetLockFile);
368
+ }
369
+ catch {
370
+ // lost a race to another writer; init resolves a lock file from scratch below
371
+ }
372
+ }
373
+ (0, child_process_1.execSync)(`${binaryName} init -backend=false -input=false`, {
374
+ cwd: workingDir,
375
+ env,
376
+ stdio: "pipe",
377
+ });
378
+ if (hadOwnLockFile) {
379
+ // only cache lock files this warm-up actually resolved, not a stack's own pinned one
380
+ return;
381
+ }
382
+ try {
383
+ fs.mkdirSync(cacheDir, { recursive: true });
384
+ const tmpLockFile = `${cachedLockFile}.${process.pid}.tmp`;
385
+ fs.copyFileSync(targetLockFile, tmpLockFile);
386
+ fs.renameSync(tmpLockFile, cachedLockFile);
387
+ }
388
+ catch {
389
+ // the cache write-back is an optimization only; a failure here must not fail the warm-up
390
+ }
391
+ }
392
+ // eslint-disable-next-line jsdoc/require-jsdoc
393
+ function getManifestStacks(received) {
394
+ const manifest = JSON.parse(fs.readFileSync(path.resolve(received, "manifest.json"), "utf8"));
395
+ return Object.entries(manifest.stacks);
396
+ }
397
+ /**
398
+ * Resolves and caches a `.terraform.lock.hcl` for every unique required-providers set across
399
+ * the given `fullSynth` output directories, up front and serially.
400
+ *
401
+ * Intended for callers that know the full set of stacks under test ahead of time — e.g. a
402
+ * Jest/Vitest `globalSetup` hook, before parallel workers start — so there's nothing left for
403
+ * `toBeValidTerraform`/`toPlanSuccessfully` to race over
404
+ * (https://github.com/open-constructs/cdk-terrain/issues/452).
405
+ *
406
+ * @param received one or more `fullSynth` output directories to warm up
407
+ */
408
+ function warmUpProviderLockFileCache(received) {
409
+ received
410
+ .flatMap((dir) => getManifestStacks(dir).map(([, stack]) => path.resolve(dir, stack.workingDirectory)))
411
+ .forEach((workingDir) => resolveAndCacheProviderLockFile(workingDir, util_1.terraformBinaryName, process.env));
412
+ }
413
+ // execSync's default 1 MiB maxBuffer is easily exceeded by `-json` output for a plan/validate
414
+ // of more than a few dozen resources.
415
+ const EXEC_MAX_BUFFER = 100 * 1024 * 1024;
416
+ /**
417
+ * Checks that the received stack is valid Terraform (`terraform validate`).
215
418
  */
216
419
  function toBeValidTerraform(received) {
217
420
  try {
@@ -223,15 +426,19 @@ function toBeValidTerraform(received) {
223
426
  return new AssertionReturn(`Expected subject to be a terraform directory: ${e}`, false);
224
427
  }
225
428
  try {
226
- const manifest = JSON.parse(fs.readFileSync(path.resolve(received, "manifest.json"), "utf8"));
227
- const stacks = Object.entries(manifest.stacks);
429
+ const stacks = getManifestStacks(received);
228
430
  stacks.forEach(([name, stack]) => {
229
431
  const opts = {
230
432
  cwd: path.resolve(received, stack.workingDirectory),
231
433
  env: process.env,
232
434
  stdio: "pipe",
435
+ maxBuffer: EXEC_MAX_BUFFER,
233
436
  };
234
- (0, child_process_1.execSync)(`${util_1.terraformBinaryName} init`, opts);
437
+ const seeded = seedFromWarmCache(opts.cwd, util_1.terraformBinaryName, opts.env);
438
+ (0, child_process_1.execSync)(`${util_1.terraformBinaryName} init -backend=false -input=false`, {
439
+ ...opts,
440
+ env: seeded ? opts.env : withoutPluginCache(opts.env),
441
+ });
235
442
  const out = (0, child_process_1.execSync)(`${util_1.terraformBinaryName} validate -json`, opts);
236
443
  const result = JSON.parse(out.toString());
237
444
  if (!result.valid) {
@@ -244,12 +451,27 @@ function toBeValidTerraform(received) {
244
451
  return new AssertionReturn(withProcessOutput(`Expected subject to be a valid terraform stack`, e), false);
245
452
  }
246
453
  }
454
+ const noRealBackendOverrideFileName = "cdktn-testing-no-backend_override.tf.json";
247
455
  /**
248
- * Evaluates the ability for the received stack to successfully plan
249
- * @param received
250
- * @returns {AssertionReturn}
456
+ * `init -backend=false` leaves the backend uninitialized, which `plan` refuses to run against
457
+ * (`fullSynth` output always has a backend block). Write a Terraform JSON override that swaps
458
+ * in a `local` backend instead, so `init` can initialize for real without credentials or
459
+ * network access.
251
460
  */
252
- function toPlanSuccessfully(received) {
461
+ function overrideWithLocalBackend(workingDir) {
462
+ fs.writeFileSync(path.join(workingDir, noRealBackendOverrideFileName), JSON.stringify({ terraform: { backend: { local: {} } } }));
463
+ }
464
+ // eslint-disable-next-line jsdoc/require-jsdoc
465
+ function removeLocalBackendOverride(workingDir) {
466
+ fs.rmSync(path.join(workingDir, noRealBackendOverrideFileName), {
467
+ force: true,
468
+ });
469
+ }
470
+ /**
471
+ * Checks that the received stack plans successfully (`terraform plan`).
472
+ */
473
+ function toPlanSuccessfully(received, options = {}) {
474
+ const { backend = true } = options;
253
475
  try {
254
476
  if (!fs.statSync(received).isDirectory()) {
255
477
  throw (0, errors_1.matchersPathIsNotDirectory)("toPlanSuccessfully");
@@ -259,17 +481,31 @@ function toPlanSuccessfully(received) {
259
481
  return new AssertionReturn(`Expected subject to be a terraform directory: ${e}`, false);
260
482
  }
261
483
  try {
262
- const manifest = JSON.parse(fs.readFileSync(path.resolve(received, "manifest.json"), "utf8"));
263
- const stacks = Object.entries(manifest.stacks);
484
+ const stacks = getManifestStacks(received);
264
485
  stacks.forEach(([, stack]) => {
265
486
  const opts = {
266
487
  cwd: path.resolve(received, stack.workingDirectory),
267
488
  env: process.env,
268
- stdio: "ignore",
489
+ stdio: "pipe",
490
+ maxBuffer: EXEC_MAX_BUFFER,
269
491
  };
270
- (0, child_process_1.execSync)(`${util_1.terraformBinaryName} init`, opts);
271
- // Throws on a non-zero exit code
272
- (0, child_process_1.execSync)(`${util_1.terraformBinaryName} plan -input=false -lock=false `, opts);
492
+ if (!backend) {
493
+ overrideWithLocalBackend(opts.cwd);
494
+ }
495
+ try {
496
+ const seeded = seedFromWarmCache(opts.cwd, util_1.terraformBinaryName, opts.env);
497
+ (0, child_process_1.execSync)(`${util_1.terraformBinaryName} init -input=false`, {
498
+ ...opts,
499
+ env: seeded ? opts.env : withoutPluginCache(opts.env),
500
+ });
501
+ // throws on a non-zero exit code
502
+ (0, child_process_1.execSync)(`${util_1.terraformBinaryName} plan -input=false -lock=false -json`, opts);
503
+ }
504
+ finally {
505
+ if (!backend) {
506
+ removeLocalBackendOverride(opts.cwd);
507
+ }
508
+ }
273
509
  });
274
510
  return new AssertionReturn(`Expected subject not to plan successfully`, true);
275
511
  }
@@ -277,4 +513,4 @@ function toPlanSuccessfully(received) {
277
513
  return new AssertionReturn(withProcessOutput(`Expected subject to plan successfully`, e), false);
278
514
  }
279
515
  }
280
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matchers.js","sourceRoot":"","sources":["../../src/testing/matchers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { execSync, SpawnSyncReturns } from \"child_process\";\nimport { snakeCase, terraformBinaryName } from \"../util\";\nimport {\n  invalidStack,\n  matchersFoundErrorsInStack,\n  matchersPathIsNotDirectory,\n} from \"../errors\";\n\n// TerraformConstructor is class with the static property 'tfResourceType'\nexport interface TerraformConstructor {\n  readonly tfResourceType: string;\n}\n\nexport type SynthesizedStack = {\n  resource: Record<string, any>;\n  data: Record<string, any>;\n  provider: Record<string, any>;\n};\n\n/**\n * Class representing the contents of a return by an assertion\n */\nexport class AssertionReturn {\n  /**\n   * Create an AssertionReturn\n   * @param message - String message containing information about the result of the assertion\n   * @param pass - Boolean pass denoting the success of the assertion\n   */\n  constructor(\n    public readonly message: string,\n    public readonly pass: boolean,\n  ) {}\n}\n\nexport type MatcherReturnJest = { message: () => string; pass: boolean };\n\n/**\n * Reformats the contents of the base testing matcher return type AssertionReturn into type useable by jest\n * @param toReturn\n * @returns {MatcherReturnJest}\n */\nexport function returnMatcherToJest(\n  toReturn: AssertionReturn,\n): MatcherReturnJest {\n  return {\n    message: () => toReturn.message,\n    pass: toReturn.pass,\n  };\n}\n\n/**\n * Compares expected and received. All expected properties are matched and considered equal even if\n * there are more properties in the received object than in the expected object in which case it will still return true.\n * @param expected\n * @param received\n * @returns {boolean}\n */\nexport function asymetricDeepEqualIgnoringObjectCasing(\n  expected: unknown,\n  received: unknown,\n): boolean {\n  switch (typeof expected) {\n    case \"object\":\n      if (Array.isArray(expected)) {\n        return (\n          Array.isArray(received) &&\n          expected.length === received.length &&\n          expected.every(\n            (item, index) =>\n              asymetricDeepEqualIgnoringObjectCasing(item, received[index]), // recursively compare arrays\n          )\n        );\n      }\n      if (expected === null && received === null) {\n        return true;\n      }\n      if (expected === undefined && received === undefined) {\n        return true;\n      }\n      if (expected === null || received === null) {\n        return false;\n      }\n\n      // recursively compare objects and allow snake case as well as camel case\n      return Object.keys(expected as Record<string, unknown>).every((key) => {\n        if ((received as any)[key] !== undefined) {\n          return asymetricDeepEqualIgnoringObjectCasing(\n            (expected as any)[key],\n            (received as any)[key],\n          );\n        }\n\n        if ((received as any)[snakeCase(key)] !== undefined) {\n          return asymetricDeepEqualIgnoringObjectCasing(\n            (expected as any)[key],\n            (received as any)[snakeCase(key)],\n          );\n        }\n\n        return false;\n      });\n    default:\n      return expected === received;\n  }\n}\nconst defaultPassEvaluation = (\n  items: any,\n  assertedProperties: Record<string, any>,\n) => {\n  return Object.values(items).some((item: any) =>\n    asymetricDeepEqualIgnoringObjectCasing(assertedProperties, item),\n  );\n};\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction isAsymmetric(obj: any) {\n  return !!obj && typeof obj === \"object\" && \"asymmetricMatch\" in obj;\n}\n// You can use expect.Anything(), expect.ObjectContaining, etc in jest, this makes it nicer to read\n// when we print error messages\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction jestAsymetricMatcherStringifyReplacer(_key: string, value: any) {\n  return isAsymmetric(value) ? `expect.${value.toString()}` : value;\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction getAssertElementWithProperties(\n  functionName: string,\n  // We have the evaluation function configurable so we can make use of the specific testing frameworks capabilities\n  // This makes the resulting tests more native to the testing framework\n  customPassEvaluation?: (\n    items: any[], // configurations of the requested type\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  const passEvaluation = customPassEvaluation || defaultPassEvaluation;\n  return function getAssertElementWithProperties(\n    type: keyof SynthesizedStack,\n    received: string,\n    itemType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    let stack: SynthesizedStack;\n\n    // Rececived could either be a JSON string or a path to a file\n    const stackContent = fs.existsSync(received)\n      ? fs.readFileSync(received, \"utf8\")\n      : received;\n\n    try {\n      stack = JSON.parse(stackContent) as SynthesizedStack;\n    } catch (e) {\n      throw invalidStack(functionName, stackContent);\n    }\n\n    const items =\n      Object.values(\n        Object.entries(stack[type] || {}) // for all data/resource entries\n          .find(\n            // find the object with a matching name\n            ([type, _values]) => type === itemType.tfResourceType,\n          )?.[1] || {}, // get all items of that type (encoded as a record of name -> config)\n      ) || []; // get a list of all configs of that type\n    const pass = passEvaluation(items, properties);\n    if (pass) {\n      return new AssertionReturn(\n        `Expected no ${\n          itemType.tfResourceType\n        } with properties ${JSON.stringify(\n          properties,\n          jestAsymetricMatcherStringifyReplacer,\n        )} to be present in synthesized stack.\nFound ${items.length === 0 ? \"no\" : items.length} ${\n          itemType.tfResourceType\n        } resources instead${\n          items.length > 0 ? \":\\n\" + JSON.stringify(items, null, 2) : \"\"\n        }`,\n        pass,\n      );\n    } else {\n      return new AssertionReturn(\n        `Expected ${itemType.tfResourceType} with properties ${JSON.stringify(\n          properties,\n          jestAsymetricMatcherStringifyReplacer,\n        )} to be present in synthesized stack.\nFound ${items.length === 0 ? \"no\" : items.length} ${\n          itemType.tfResourceType\n        } resources instead${\n          items.length > 0 ? \":\\n\" + JSON.stringify(items, null, 2) : \"\"\n        }`,\n        pass,\n      );\n    }\n  };\n}\n\n/**\n * Returns the function toHaveDataSourceWithProperties using the evaluation properties of customPassEvaluation\n * @param customPassEvaluation\n * @returns {getToHaveDataSourceWithProperties~toHaveDataSourceWithProperties}\n */\nexport function getToHaveDataSourceWithProperties(\n  customPassEvaluation?: (\n    items: any,\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  /**\n   * Evaluates the received stack to have the data source resourceType containing specified properties\n   * @param received\n   * @param resourceType\n   * @param properties\n   * @returns {AssertionReturn}\n   */\n  return function toHaveDataSourceWithProperties(\n    received: string,\n    resourceType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    return getAssertElementWithProperties(\n      \"toHaveDataSourceWithProperties\",\n      customPassEvaluation,\n    )(\"data\", received, resourceType, properties);\n  };\n}\n\n/**\n * Returns the function toHaveResourceWithProperties using the evaluation properties of customPassEvaluation\n * @param customPassEvaluation\n * @returns\n */\nexport function getToHaveResourceWithProperties(\n  customPassEvaluation?: (\n    items: any,\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  /**\n   * Evaluates the received stack to have the resource resourceType containing specified properties\n   * @param received\n   * @param resourceType\n   * @param properties\n   * @returns {AssertionReturn}\n   */\n  return function toHaveResourceWithProperties(\n    received: string,\n    resourceType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    return getAssertElementWithProperties(\n      \"toHaveResourceWithProperties\",\n      customPassEvaluation,\n    )(\"resource\", received, resourceType, properties);\n  };\n}\n\n/**\n * A helper util to verify wether an Error was caused by the Nodejs `process.spawn` API.\n *\n * @param   {Error}   err The Error object to verify\n * @returns {Boolean}     A bool indicating wether the input Error is containing process.spawn output.\n */\nconst isExecSpawnError = (err: any): err is Error & SpawnSyncReturns<any> =>\n  \"output\" in err &&\n  Array.isArray(err.output) &&\n  err.output.some((buf: any) => Buffer.isBuffer(buf));\n\n/**\n * A helper util to append `process.spawn` output to assertion messages to improve developer expirience.\n *\n * @param   {String} message The message to optionally append process output to.\n * @param   {Error}  err     The error from which the `process.spawn` output should be retreived from.\n * @returns {String}         The finalized assertion message decorated with the `process.spawn` output.\n */\nconst withProcessOutput = (message: string, err: unknown) => {\n  let output = \"\";\n\n  if (isExecSpawnError(err)) {\n    output =\n      err.output\n        ?.map((buffer: Buffer) => buffer?.toString(\"utf8\"))\n        .filter(Boolean)\n        .join(\"\\n\") ?? \"\";\n  }\n\n  const appendix = output.length ? `. Output: ${output}` : \"\";\n\n  return `${message}: ${err}${appendix}.`;\n};\n\n/**\n * Returns the function toHaveProviderWithProperties using the evaluation properties of customPassEvaluation\n * @param customPassEvaluation\n * @returns {getToHaveProviderWithProperties~toHaveProviderWithProperties}\n */\nexport function getToHaveProviderWithProperties(\n  customPassEvaluation?: (\n    items: any,\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  /**\n   * Evaluates the received stack to have the provider resourceType containing specified properties\n   * @param received\n   * @param resourceType\n   * @param properties\n   * @returns {AssertionReturn}\n   */\n  return function toHaveProviderWithProperties(\n    received: string,\n    resourceType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    return getAssertElementWithProperties(\n      \"toHaveProviderWithProperties\",\n      customPassEvaluation,\n    )(\"provider\", received, resourceType, properties);\n  };\n}\n\n/**\n * Evaluates the validity of the received stack\n * @param received\n * @returns {AssertionReturn}\n */\nexport function toBeValidTerraform(received: string): AssertionReturn {\n  try {\n    if (!fs.statSync(received).isDirectory()) {\n      throw matchersPathIsNotDirectory(\"toBeValidTerraform\");\n    }\n  } catch (e) {\n    return new AssertionReturn(\n      `Expected subject to be a terraform directory: ${e}`,\n      false,\n    );\n  }\n\n  try {\n    const manifest = JSON.parse(\n      fs.readFileSync(path.resolve(received, \"manifest.json\"), \"utf8\"),\n    );\n\n    const stacks = Object.entries(manifest.stacks);\n\n    stacks.forEach(([name, stack]) => {\n      const opts = {\n        cwd: path.resolve(received, (stack as any).workingDirectory),\n        env: process.env,\n        stdio: \"pipe\",\n      } as any;\n      execSync(`${terraformBinaryName} init`, opts);\n      const out = execSync(`${terraformBinaryName} validate -json`, opts);\n\n      const result = JSON.parse(out.toString());\n      if (!result.valid) {\n        throw matchersFoundErrorsInStack(\n          result.error_count,\n          name,\n          result.diagnostics.join(\"\\n\"),\n        );\n      }\n    });\n    return new AssertionReturn(\n      `Expected subject not to be a valid terraform stack`,\n      true,\n    );\n  } catch (e) {\n    return new AssertionReturn(\n      withProcessOutput(`Expected subject to be a valid terraform stack`, e),\n      false,\n    );\n  }\n}\n\n/**\n * Evaluates the ability for the received stack to successfully plan\n * @param received\n * @returns {AssertionReturn}\n */\nexport function toPlanSuccessfully(received: string): AssertionReturn {\n  try {\n    if (!fs.statSync(received).isDirectory()) {\n      throw matchersPathIsNotDirectory(\"toPlanSuccessfully\");\n    }\n  } catch (e) {\n    return new AssertionReturn(\n      `Expected subject to be a terraform directory: ${e}`,\n      false,\n    );\n  }\n\n  try {\n    const manifest = JSON.parse(\n      fs.readFileSync(path.resolve(received, \"manifest.json\"), \"utf8\"),\n    );\n\n    const stacks = Object.entries(manifest.stacks);\n\n    stacks.forEach(([, stack]) => {\n      const opts = {\n        cwd: path.resolve(received, (stack as any).workingDirectory),\n        env: process.env,\n        stdio: \"ignore\",\n      } as any;\n      execSync(`${terraformBinaryName} init`, opts);\n\n      // Throws on a non-zero exit code\n      execSync(`${terraformBinaryName} plan -input=false -lock=false `, opts);\n    });\n\n    return new AssertionReturn(\n      `Expected subject not to plan successfully`,\n      true,\n    );\n  } catch (e) {\n    return new AssertionReturn(\n      withProcessOutput(`Expected subject to plan successfully`, e),\n      false,\n    );\n  }\n}\n"]}
516
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matchers.js","sourceRoot":"","sources":["../../src/testing/matchers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport * as crypto from \"crypto\";\nimport { execSync, SpawnSyncReturns } from \"child_process\";\nimport { snakeCase, terraformBinaryName } from \"../util\";\nimport {\n  invalidStack,\n  matchersFoundErrorsInStack,\n  matchersPathIsNotDirectory,\n} from \"../errors\";\n\nexport interface TerraformConstructor {\n  readonly tfResourceType: string;\n}\n\nexport type SynthesizedStack = {\n  resource: Record<string, any>;\n  data: Record<string, any>;\n  provider: Record<string, any>;\n};\n\n/**\n * The result of a testing matcher assertion.\n */\nexport class AssertionReturn {\n  constructor(\n    public readonly message: string,\n    public readonly pass: boolean,\n  ) {}\n}\n\nexport type MatcherReturnJest = { message: () => string; pass: boolean };\n\n/**\n * Adapts an {@link AssertionReturn} to Jest's `{ message, pass }` matcher shape.\n */\nexport function returnMatcherToJest(\n  toReturn: AssertionReturn,\n): MatcherReturnJest {\n  return {\n    message: () => toReturn.message,\n    pass: toReturn.pass,\n  };\n}\n\n/**\n * Deep-equals `expected` against `received`, ignoring extra properties on `received` and\n * matching each key in either camelCase or snake_case.\n */\nexport function asymetricDeepEqualIgnoringObjectCasing(\n  expected: unknown,\n  received: unknown,\n): boolean {\n  switch (typeof expected) {\n    case \"object\":\n      if (Array.isArray(expected)) {\n        return (\n          Array.isArray(received) &&\n          expected.length === received.length &&\n          expected.every((item, index) =>\n            asymetricDeepEqualIgnoringObjectCasing(item, received[index]),\n          )\n        );\n      }\n      if (expected === null && received === null) {\n        return true;\n      }\n      if (expected === undefined && received === undefined) {\n        return true;\n      }\n      if (expected === null || received === null) {\n        return false;\n      }\n\n      return Object.keys(expected as Record<string, unknown>).every((key) => {\n        if ((received as any)[key] !== undefined) {\n          return asymetricDeepEqualIgnoringObjectCasing(\n            (expected as any)[key],\n            (received as any)[key],\n          );\n        }\n\n        if ((received as any)[snakeCase(key)] !== undefined) {\n          return asymetricDeepEqualIgnoringObjectCasing(\n            (expected as any)[key],\n            (received as any)[snakeCase(key)],\n          );\n        }\n\n        return false;\n      });\n    default:\n      return expected === received;\n  }\n}\nconst defaultPassEvaluation = (\n  items: any,\n  assertedProperties: Record<string, any>,\n) => {\n  return Object.values(items).some((item: any) =>\n    asymetricDeepEqualIgnoringObjectCasing(assertedProperties, item),\n  );\n};\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction isAsymmetric(obj: any) {\n  return !!obj && typeof obj === \"object\" && \"asymmetricMatch\" in obj;\n}\n// Renders jest asymmetric matchers (expect.anything(), etc.) as \"expect.Anything()\" in messages,\n// instead of their internal object representation.\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction jestAsymetricMatcherStringifyReplacer(_key: string, value: any) {\n  return isAsymmetric(value) ? `expect.${value.toString()}` : value;\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction getAssertElementWithProperties(\n  functionName: string,\n  // Configurable so each adapter (Jest, Vitest, ...) can use its own matcher semantics.\n  customPassEvaluation?: (\n    items: any[],\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  const passEvaluation = customPassEvaluation || defaultPassEvaluation;\n  return function getAssertElementWithProperties(\n    type: keyof SynthesizedStack,\n    received: string,\n    itemType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    let stack: SynthesizedStack;\n\n    // received may be a JSON string or a path to a file containing one\n    const stackContent = fs.existsSync(received)\n      ? fs.readFileSync(received, \"utf8\")\n      : received;\n\n    try {\n      stack = JSON.parse(stackContent) as SynthesizedStack;\n    } catch (e) {\n      throw invalidStack(functionName, stackContent);\n    }\n\n    // find every item of itemType.tfResourceType under stack[type], keyed by name\n    const items =\n      Object.values(\n        Object.entries(stack[type] || {}).find(\n          ([type, _values]) => type === itemType.tfResourceType,\n        )?.[1] || {},\n      ) || [];\n    const pass = passEvaluation(items, properties);\n    if (pass) {\n      return new AssertionReturn(\n        `Expected no ${\n          itemType.tfResourceType\n        } with properties ${JSON.stringify(\n          properties,\n          jestAsymetricMatcherStringifyReplacer,\n        )} to be present in synthesized stack.\nFound ${items.length === 0 ? \"no\" : items.length} ${\n          itemType.tfResourceType\n        } resources instead${\n          items.length > 0 ? \":\\n\" + JSON.stringify(items, null, 2) : \"\"\n        }`,\n        pass,\n      );\n    } else {\n      return new AssertionReturn(\n        `Expected ${itemType.tfResourceType} with properties ${JSON.stringify(\n          properties,\n          jestAsymetricMatcherStringifyReplacer,\n        )} to be present in synthesized stack.\nFound ${items.length === 0 ? \"no\" : items.length} ${\n          itemType.tfResourceType\n        } resources instead${\n          items.length > 0 ? \":\\n\" + JSON.stringify(items, null, 2) : \"\"\n        }`,\n        pass,\n      );\n    }\n  };\n}\n\n/**\n * Returns a `toHaveDataSourceWithProperties` matcher using `customPassEvaluation` to decide a\n * match.\n */\nexport function getToHaveDataSourceWithProperties(\n  customPassEvaluation?: (\n    items: any,\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  return function toHaveDataSourceWithProperties(\n    received: string,\n    resourceType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    return getAssertElementWithProperties(\n      \"toHaveDataSourceWithProperties\",\n      customPassEvaluation,\n    )(\"data\", received, resourceType, properties);\n  };\n}\n\n/**\n * Returns a `toHaveResourceWithProperties` matcher using `customPassEvaluation` to decide a\n * match.\n */\nexport function getToHaveResourceWithProperties(\n  customPassEvaluation?: (\n    items: any,\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  return function toHaveResourceWithProperties(\n    received: string,\n    resourceType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    return getAssertElementWithProperties(\n      \"toHaveResourceWithProperties\",\n      customPassEvaluation,\n    )(\"resource\", received, resourceType, properties);\n  };\n}\n\n/**\n * Reports whether `err` carries `child_process.execSync`/`spawnSync` output buffers.\n */\nconst isExecSpawnError = (err: any): err is Error & SpawnSyncReturns<any> =>\n  \"output\" in err &&\n  Array.isArray(err.output) &&\n  err.output.some((buf: any) => Buffer.isBuffer(buf));\n\n/**\n * Renders terraform diagnostic entries as human-readable text.\n */\nconst formatDiagnostics = (diagnostics: any[]): string =>\n  diagnostics\n    .filter((d) => d?.severity && d?.summary)\n    .map(\n      ({ severity, summary, detail }) =>\n        `${severity}: ${summary}${detail ? `\\n${detail}` : \"\"}`,\n    )\n    .join(\"\\n\");\n\n/**\n * Renders the diagnostics found in the output of a `terraform <cmd> -json` invocation as\n * human-readable text. Handles both `plan`'s newline-delimited JSON stream (one `diagnostic`\n * entry per line) and `validate`'s single pretty-printed object (a top-level `diagnostics`\n * array).\n */\nconst renderJsonDiagnostics = (output: string): string => {\n  try {\n    const parsed = JSON.parse(output);\n    if (Array.isArray(parsed?.diagnostics)) {\n      return formatDiagnostics(parsed.diagnostics);\n    }\n  } catch {\n    // not a single JSON object; fall through to the newline-delimited format\n  }\n\n  const diagnostics = output\n    .split(\"\\n\")\n    .map((line) => {\n      try {\n        return JSON.parse(line);\n      } catch {\n        return undefined;\n      }\n    })\n    .filter((entry) => entry?.type === \"diagnostic\" && entry.diagnostic)\n    .map((entry) => entry.diagnostic);\n\n  return formatDiagnostics(diagnostics);\n};\n\n/**\n * Appends a failed process's output to an assertion message, preferring rendered `-json`\n * diagnostics over the raw output when available.\n */\nconst withProcessOutput = (message: string, err: unknown) => {\n  if (!isExecSpawnError(err)) {\n    return `${message}: ${err}.`;\n  }\n\n  const output =\n    err.output\n      ?.map((buffer: Buffer) => buffer?.toString(\"utf8\"))\n      .filter(Boolean)\n      .join(\"\\n\") ?? \"\";\n\n  // Diagnostics are parsed from stdout alone: concatenating stderr (e.g. a CLI-config error)\n  // into the mix would break the single-object parse `-json` output relies on.\n  const diagnostics = renderJsonDiagnostics(err.stdout?.toString(\"utf8\") ?? \"\");\n  const appendix = diagnostics.length\n    ? `. Diagnostics: ${diagnostics}`\n    : output.length\n      ? `. Output: ${output}`\n      : \"\";\n\n  return `${message}: ${err}${appendix}.`;\n};\n\n/**\n * Returns a `toHaveProviderWithProperties` matcher using `customPassEvaluation` to decide a\n * match.\n */\nexport function getToHaveProviderWithProperties(\n  customPassEvaluation?: (\n    items: any,\n    assertedProperties: Record<string, any>,\n  ) => boolean,\n) {\n  return function toHaveProviderWithProperties(\n    received: string,\n    resourceType: TerraformConstructor,\n    properties: Record<string, any> = {},\n  ): AssertionReturn {\n    return getAssertElementWithProperties(\n      \"toHaveProviderWithProperties\",\n      customPassEvaluation,\n    )(\"provider\", received, resourceType, properties);\n  };\n}\n\n/**\n * The root directory the provider lock-file cache is written under. Overridable via\n * `CDKTN_TESTING_LOCKFILE_CACHE_DIR` so tests can assert on what gets written to it instead of\n * sharing the real machine-global cache, and so CI can point it at a directory persisted\n * between jobs.\n */\nfunction getProviderLockFileCacheRoot(): string {\n  return (\n    process.env.CDKTN_TESTING_LOCKFILE_CACHE_DIR ??\n    path.join(os.tmpdir(), \"cdktn-testing-provider-lockfiles\")\n  );\n}\n\n// A loosely pinned requirement (e.g. \"~> 5.0\") shouldn't stay pinned to whichever version a\n// machine first resolved forever, so the cache expires.\nconst CACHE_TTL_MS = 24 * 60 * 60 * 1000;\n\nconst binaryVersionCache = new Map<string, string>();\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction getBinaryVersion(binaryName: string, env: NodeJS.ProcessEnv): string {\n  const cached = binaryVersionCache.get(binaryName);\n  if (cached) {\n    return cached;\n  }\n\n  let version = \"unknown\";\n  try {\n    version = execSync(`${binaryName} version`, { env, stdio: \"pipe\" })\n      .toString(\"utf8\")\n      .split(\"\\n\")[0];\n  } catch {\n    // only affects cache partitioning, so \"unknown\" is an acceptable fallback\n  }\n\n  binaryVersionCache.set(binaryName, version);\n  return version;\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction getProviderLockCacheDir(\n  workingDir: string,\n  binaryName: string,\n  env: NodeJS.ProcessEnv,\n): string | undefined {\n  try {\n    const config = JSON.parse(\n      fs.readFileSync(path.join(workingDir, \"cdk.tf.json\"), \"utf8\"),\n    );\n    const cacheKey = crypto\n      .createHash(\"sha256\")\n      .update(binaryName)\n      .update(getBinaryVersion(binaryName, env))\n      .update(JSON.stringify(config?.terraform?.required_providers ?? {}))\n      .digest(\"hex\");\n    return path.join(getProviderLockFileCacheRoot(), cacheKey);\n  } catch {\n    return undefined;\n  }\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction isCachedLockFileFresh(cachedLockFile: string): boolean {\n  try {\n    return Date.now() - fs.statSync(cachedLockFile).mtimeMs < CACHE_TTL_MS;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Copies a cached `.terraform.lock.hcl` into `workingDir` if `warmUpProviderLockFileCache` has\n * already resolved one for its exact set of required providers, and it hasn't expired. Never\n * runs `init` itself. A `workingDir` that already has its own lock file is left untouched —\n * real stack directories keep a pinned one (`cli-core` reads it from there), and overwriting it\n * with the cached one would silently swap its versions.\n *\n * @returns whether a lock file was seeded.\n */\nfunction seedFromWarmCache(\n  workingDir: string,\n  binaryName: string,\n  env: NodeJS.ProcessEnv,\n): boolean {\n  const targetLockFile = path.join(workingDir, \".terraform.lock.hcl\");\n  if (fs.existsSync(targetLockFile)) {\n    return false;\n  }\n\n  const cacheDir = getProviderLockCacheDir(workingDir, binaryName, env);\n  if (!cacheDir) {\n    return false;\n  }\n\n  const cachedLockFile = path.join(cacheDir, \".terraform.lock.hcl\");\n  if (!isCachedLockFileFresh(cachedLockFile)) {\n    return false;\n  }\n\n  fs.copyFileSync(cachedLockFile, targetLockFile);\n  return true;\n}\n\n/**\n * Removes `TF_PLUGIN_CACHE_DIR` from `env`. Without a seeded lock file, `init` resolves\n * providers itself; against terraform >= 1.4 that re-downloads into the shared plugin cache\n * even when it's warm, racing other concurrent `init`s\n * (https://github.com/open-constructs/cdk-terrain/issues/452). Dropping the cache dir from the\n * environment makes `init` resolve into the stack's own `.terraform` directory instead, so it\n * can't race another worker's writes to the shared cache. This doesn't cover a `plugin_cache_dir`\n * set in the user's CLI config file rather than the environment, and\n * `warmUpProviderLockFileCache` is still expected to run once per machine at a time — two warm-ups\n * racing a cold plugin cache would hit the same race this works around.\n */\nfunction withoutPluginCache(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {\n  const { TF_PLUGIN_CACHE_DIR: _unused, ...rest } = env;\n  return rest;\n}\n\n/**\n * Resolves and caches a `.terraform.lock.hcl` for the exact set of required providers in\n * `workingDir`, running a real `init` against the shared plugin cache. Only ever called from\n * `warmUpProviderLockFileCache`, which runs serially within a single process, so no cross-\n * process lock is needed: it's the only writer to the cache.\n *\n * `init` always runs, even when a fresh cached lock file exists: the lock-file cache and\n * `TF_PLUGIN_CACHE_DIR` have independent lifetimes, so a fresh lock doesn't guarantee the\n * providers it pins are still sitting in the plugin cache. Seeding the cached lock first (when\n * `workingDir` doesn't already have one of its own, and the cache hasn't expired) just lets\n * that `init` take the verified-checksum path instead of resolving from scratch. A stale cache\n * is left alone so `init` re-resolves it, otherwise a loosely pinned requirement (e.g. `~> 5.0`)\n * would stay pinned to whatever version this cache entry first resolved, forever.\n */\nfunction resolveAndCacheProviderLockFile(\n  workingDir: string,\n  binaryName: string,\n  env: NodeJS.ProcessEnv,\n): void {\n  const cacheDir = getProviderLockCacheDir(workingDir, binaryName, env);\n  if (!cacheDir) {\n    return;\n  }\n\n  const targetLockFile = path.join(workingDir, \".terraform.lock.hcl\");\n  const cachedLockFile = path.join(cacheDir, \".terraform.lock.hcl\");\n  const hadOwnLockFile = fs.existsSync(targetLockFile);\n  if (!hadOwnLockFile && isCachedLockFileFresh(cachedLockFile)) {\n    try {\n      fs.copyFileSync(cachedLockFile, targetLockFile);\n    } catch {\n      // lost a race to another writer; init resolves a lock file from scratch below\n    }\n  }\n\n  execSync(`${binaryName} init -backend=false -input=false`, {\n    cwd: workingDir,\n    env,\n    stdio: \"pipe\",\n  });\n\n  if (hadOwnLockFile) {\n    // only cache lock files this warm-up actually resolved, not a stack's own pinned one\n    return;\n  }\n\n  try {\n    fs.mkdirSync(cacheDir, { recursive: true });\n    const tmpLockFile = `${cachedLockFile}.${process.pid}.tmp`;\n    fs.copyFileSync(targetLockFile, tmpLockFile);\n    fs.renameSync(tmpLockFile, cachedLockFile);\n  } catch {\n    // the cache write-back is an optimization only; a failure here must not fail the warm-up\n  }\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction getManifestStacks(\n  received: string,\n): [string, { workingDirectory: string }][] {\n  const manifest = JSON.parse(\n    fs.readFileSync(path.resolve(received, \"manifest.json\"), \"utf8\"),\n  );\n  return Object.entries(manifest.stacks);\n}\n\n/**\n * Resolves and caches a `.terraform.lock.hcl` for every unique required-providers set across\n * the given `fullSynth` output directories, up front and serially.\n *\n * Intended for callers that know the full set of stacks under test ahead of time — e.g. a\n * Jest/Vitest `globalSetup` hook, before parallel workers start — so there's nothing left for\n * `toBeValidTerraform`/`toPlanSuccessfully` to race over\n * (https://github.com/open-constructs/cdk-terrain/issues/452).\n *\n * @param received one or more `fullSynth` output directories to warm up\n */\nexport function warmUpProviderLockFileCache(received: string[]): void {\n  received\n    .flatMap((dir) =>\n      getManifestStacks(dir).map(([, stack]) =>\n        path.resolve(dir, stack.workingDirectory),\n      ),\n    )\n    .forEach((workingDir) =>\n      resolveAndCacheProviderLockFile(\n        workingDir,\n        terraformBinaryName,\n        process.env,\n      ),\n    );\n}\n\n// execSync's default 1 MiB maxBuffer is easily exceeded by `-json` output for a plan/validate\n// of more than a few dozen resources.\nconst EXEC_MAX_BUFFER = 100 * 1024 * 1024;\n\n/**\n * Checks that the received stack is valid Terraform (`terraform validate`).\n */\nexport function toBeValidTerraform(received: string): AssertionReturn {\n  try {\n    if (!fs.statSync(received).isDirectory()) {\n      throw matchersPathIsNotDirectory(\"toBeValidTerraform\");\n    }\n  } catch (e) {\n    return new AssertionReturn(\n      `Expected subject to be a terraform directory: ${e}`,\n      false,\n    );\n  }\n\n  try {\n    const stacks = getManifestStacks(received);\n\n    stacks.forEach(([name, stack]) => {\n      const opts = {\n        cwd: path.resolve(received, stack.workingDirectory),\n        env: process.env,\n        stdio: \"pipe\",\n        maxBuffer: EXEC_MAX_BUFFER,\n      } as any;\n      const seeded = seedFromWarmCache(opts.cwd, terraformBinaryName, opts.env);\n      execSync(`${terraformBinaryName} init -backend=false -input=false`, {\n        ...opts,\n        env: seeded ? opts.env : withoutPluginCache(opts.env),\n      });\n      const out = execSync(`${terraformBinaryName} validate -json`, opts);\n\n      const result = JSON.parse(out.toString());\n      if (!result.valid) {\n        throw matchersFoundErrorsInStack(\n          result.error_count,\n          name,\n          result.diagnostics.join(\"\\n\"),\n        );\n      }\n    });\n    return new AssertionReturn(\n      `Expected subject not to be a valid terraform stack`,\n      true,\n    );\n  } catch (e) {\n    return new AssertionReturn(\n      withProcessOutput(`Expected subject to be a valid terraform stack`, e),\n      false,\n    );\n  }\n}\n\nexport interface ToPlanSuccessfullyOptions {\n  /**\n   * Whether `init`/`plan` should use the stack's real backend. Disable this for stacks whose\n   * backend (e.g. s3, remote) is not reachable in the test environment and whose plan does not\n   * depend on existing state.\n   * @default true\n   */\n  readonly backend?: boolean;\n}\n\nconst noRealBackendOverrideFileName =\n  \"cdktn-testing-no-backend_override.tf.json\";\n\n/**\n * `init -backend=false` leaves the backend uninitialized, which `plan` refuses to run against\n * (`fullSynth` output always has a backend block). Write a Terraform JSON override that swaps\n * in a `local` backend instead, so `init` can initialize for real without credentials or\n * network access.\n */\nfunction overrideWithLocalBackend(workingDir: string) {\n  fs.writeFileSync(\n    path.join(workingDir, noRealBackendOverrideFileName),\n    JSON.stringify({ terraform: { backend: { local: {} } } }),\n  );\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction removeLocalBackendOverride(workingDir: string) {\n  fs.rmSync(path.join(workingDir, noRealBackendOverrideFileName), {\n    force: true,\n  });\n}\n\n/**\n * Checks that the received stack plans successfully (`terraform plan`).\n */\nexport function toPlanSuccessfully(\n  received: string,\n  options: ToPlanSuccessfullyOptions = {},\n): AssertionReturn {\n  const { backend = true } = options;\n\n  try {\n    if (!fs.statSync(received).isDirectory()) {\n      throw matchersPathIsNotDirectory(\"toPlanSuccessfully\");\n    }\n  } catch (e) {\n    return new AssertionReturn(\n      `Expected subject to be a terraform directory: ${e}`,\n      false,\n    );\n  }\n\n  try {\n    const stacks = getManifestStacks(received);\n\n    stacks.forEach(([, stack]) => {\n      const opts = {\n        cwd: path.resolve(received, stack.workingDirectory),\n        env: process.env,\n        stdio: \"pipe\",\n        maxBuffer: EXEC_MAX_BUFFER,\n      } as any;\n\n      if (!backend) {\n        overrideWithLocalBackend(opts.cwd);\n      }\n\n      try {\n        const seeded = seedFromWarmCache(\n          opts.cwd,\n          terraformBinaryName,\n          opts.env,\n        );\n        execSync(`${terraformBinaryName} init -input=false`, {\n          ...opts,\n          env: seeded ? opts.env : withoutPluginCache(opts.env),\n        });\n\n        // throws on a non-zero exit code\n        execSync(\n          `${terraformBinaryName} plan -input=false -lock=false -json`,\n          opts,\n        );\n      } finally {\n        if (!backend) {\n          removeLocalBackendOverride(opts.cwd);\n        }\n      }\n    });\n\n    return new AssertionReturn(\n      `Expected subject not to plan successfully`,\n      true,\n    );\n  } catch (e) {\n    return new AssertionReturn(\n      withProcessOutput(`Expected subject to plan successfully`, e),\n      false,\n    );\n  }\n}\n"]}