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.
- package/.jsii +2194 -424
- package/README.md +12 -0
- package/lib/annotations.js +4 -4
- package/lib/app.js +54 -5
- package/lib/aspect.js +3 -4
- package/lib/asset-hash.d.ts +75 -0
- package/lib/asset-hash.js +129 -0
- package/lib/asset-staging.d.ts +180 -0
- package/lib/asset-staging.js +464 -0
- package/lib/assets.d.ts +401 -0
- package/lib/assets.js +333 -0
- package/lib/backends/azurerm-backend.js +4 -6
- package/lib/backends/cloud-backend.js +15 -12
- package/lib/backends/consul-backend.js +4 -6
- package/lib/backends/cos-backend.js +4 -6
- package/lib/backends/gcs-backend.js +4 -6
- package/lib/backends/http-backend.js +4 -6
- package/lib/backends/local-backend.js +38 -7
- package/lib/backends/oss-backend.js +4 -6
- package/lib/backends/pg-backend.js +4 -6
- package/lib/backends/remote-backend.js +8 -10
- package/lib/backends/s3-backend.js +4 -6
- package/lib/backends/swift-backend.js +4 -6
- package/lib/complex-computed-list.js +114 -65
- package/lib/errors.d.ts +16 -0
- package/lib/errors.js +51 -3
- package/lib/functions/provider-function.js +2 -4
- package/lib/functions/terraform-functions.generated.js +2 -4
- package/lib/ignore-strategy.d.ts +82 -0
- package/lib/ignore-strategy.js +29 -0
- package/lib/importable-resource.js +8 -6
- package/lib/index.d.ts +4 -0
- package/lib/index.js +28 -2
- package/lib/manifest.js +49 -11
- package/lib/private/fs.d.ts +74 -2
- package/lib/private/fs.js +129 -17
- package/lib/private/unique.js +35 -2
- package/lib/resource.js +3 -4
- package/lib/synthesize/synthesizer.js +51 -25
- package/lib/terraform-asset.d.ts +68 -5
- package/lib/terraform-asset.js +127 -40
- package/lib/terraform-backend.js +3 -4
- package/lib/terraform-count.js +3 -4
- package/lib/terraform-data-resource.d.ts +1 -1
- package/lib/terraform-data-resource.js +18 -13
- package/lib/terraform-data-source.js +10 -4
- package/lib/terraform-dynamic-block.js +5 -2
- package/lib/terraform-dynamic-expression.js +4 -1
- package/lib/terraform-element.js +34 -6
- package/lib/terraform-ephemeral-resource.js +10 -4
- package/lib/terraform-functions.js +2 -4
- package/lib/terraform-hcl-module.js +3 -4
- package/lib/terraform-iterator.js +11 -12
- package/lib/terraform-local.js +3 -4
- package/lib/terraform-module-asset.js +39 -4
- package/lib/terraform-module.js +8 -4
- package/lib/terraform-operators.js +2 -4
- package/lib/terraform-output.js +7 -4
- package/lib/terraform-provider.js +5 -4
- package/lib/terraform-provisioner.js +2 -4
- package/lib/terraform-remote-state.js +5 -5
- package/lib/terraform-resource-targets.js +3 -7
- package/lib/terraform-resource.js +23 -7
- package/lib/terraform-stack.js +38 -38
- package/lib/terraform-variable.js +25 -22
- package/lib/testing/adapters/jest.d.ts +2 -1
- package/lib/testing/adapters/jest.js +3 -3
- package/lib/testing/index.js +42 -8
- package/lib/testing/matchers.d.ts +34 -30
- package/lib/testing/matchers.js +329 -93
- package/lib/tfExpression.js +25 -8
- package/lib/tokens/lazy.js +11 -7
- package/lib/tokens/private/dependency.js +2 -2
- package/lib/tokens/private/encoding.js +6 -1
- package/lib/tokens/private/intrinsic.js +6 -1
- package/lib/tokens/private/resolve.js +2 -5
- package/lib/tokens/private/token-map.js +4 -6
- package/lib/tokens/private/uniqueid.js +35 -2
- package/lib/tokens/resolvable.js +4 -6
- package/lib/tokens/string-fragments.js +6 -10
- package/lib/tokens/token.js +15 -18
- package/lib/upgrade-id-aspect.js +37 -6
- package/lib/validations/index.d.ts +0 -1
- package/lib/validations/index.js +1 -2
- package/lib/validations/target-versions.js +39 -2
- package/lib/validations/validate-function-version-support.js +2 -1
- package/lib/validations/validate-provider-function-target-support.js +2 -1
- package/lib/validations/validate-provider-presence.js +10 -9
- package/package.json +21 -7
- package/scripts/pack.mjs +27 -12
- package/lib/validations/validate-binary-version.d.ts +0 -23
- package/lib/validations/validate-binary-version.js +0 -54
- package/lib/validations/validate-terraform-version.d.ts +0 -13
- package/lib/validations/validate-terraform-version.js +0 -21
package/lib/testing/matchers.js
CHANGED
|
@@ -1,5 +1,37 @@
|
|
|
1
1
|
"use strict";
|
|
2
|
-
var
|
|
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
|
|
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
|
-
*
|
|
56
|
+
* The result of a testing matcher assertion.
|
|
22
57
|
*/
|
|
23
58
|
class AssertionReturn {
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
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
|
-
*
|
|
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
|
-
*
|
|
50
|
-
*
|
|
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
|
-
//
|
|
94
|
-
//
|
|
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
|
-
//
|
|
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
|
-
//
|
|
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
|
-
|
|
118
|
-
|
|
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
|
|
134
|
-
*
|
|
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
|
|
151
|
-
*
|
|
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
|
-
*
|
|
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
|
-
*
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
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
|
-
|
|
184
|
-
|
|
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
|
|
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
|
|
196
|
-
*
|
|
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
|
-
*
|
|
213
|
-
*
|
|
214
|
-
*
|
|
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
|
|
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
|
-
(
|
|
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
|
-
*
|
|
249
|
-
*
|
|
250
|
-
*
|
|
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
|
|
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
|
|
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: "
|
|
489
|
+
stdio: "pipe",
|
|
490
|
+
maxBuffer: EXEC_MAX_BUFFER,
|
|
269
491
|
};
|
|
270
|
-
(
|
|
271
|
-
|
|
272
|
-
|
|
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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,kDAOC;AAMD,wFA6CC;AA6FD,8EAgBC;AAMD,0EAgBC;AAoFD,0EAgBC;AAsMD,kEAcC;AASD,gDAgDC;AAsCD,gDAiEC;;AA5rBD,+BAA+B;AAC/B,mCAAmC;AACnC,uCAAyB;AACzB,uCAAyB;AACzB,2CAA6B;AAC7B,+CAAiC;AACjC,iDAA2D;AAC3D,kCAAyD;AACzD,sCAImB;AAYnB;;GAEG;AACH,MAAa,eAAe;IAER;IACA;;IAFlB,YACkB,OAAe,EACf,IAAa;QADb,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAS;IAC5B,CAAC;;AAJN,0CAKC;AAID;;GAEG;AACH,SAAgB,mBAAmB,CACjC,QAAyB;IAEzB,OAAO;QACL,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO;QAC/B,IAAI,EAAE,QAAQ,CAAC,IAAI;KACpB,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,sCAAsC,CACpD,QAAiB,EACjB,QAAiB;IAEjB,QAAQ,OAAO,QAAQ,EAAE,CAAC;QACxB,KAAK,QAAQ;YACX,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC5B,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;oBACvB,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM;oBACnC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAC7B,sCAAsC,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAC9D,CACF,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;gBAC3C,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBACrD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;gBAC3C,OAAO,KAAK,CAAC;YACf,CAAC;YAED,OAAO,MAAM,CAAC,IAAI,CAAC,QAAmC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;gBACpE,IAAK,QAAgB,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;oBACzC,OAAO,sCAAsC,CAC1C,QAAgB,CAAC,GAAG,CAAC,EACrB,QAAgB,CAAC,GAAG,CAAC,CACvB,CAAC;gBACJ,CAAC;gBAED,IAAK,QAAgB,CAAC,IAAA,gBAAS,EAAC,GAAG,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;oBACpD,OAAO,sCAAsC,CAC1C,QAAgB,CAAC,GAAG,CAAC,EACrB,QAAgB,CAAC,IAAA,gBAAS,EAAC,GAAG,CAAC,CAAC,CAClC,CAAC;gBACJ,CAAC;gBAED,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,CAAC;QACL;YACE,OAAO,QAAQ,KAAK,QAAQ,CAAC;IACjC,CAAC;AACH,CAAC;AACD,MAAM,qBAAqB,GAAG,CAC5B,KAAU,EACV,kBAAuC,EACvC,EAAE;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,IAAS,EAAE,EAAE,CAC7C,sCAAsC,CAAC,kBAAkB,EAAE,IAAI,CAAC,CACjE,CAAC;AACJ,CAAC,CAAC;AAEF,+CAA+C;AAC/C,SAAS,YAAY,CAAC,GAAQ;IAC5B,OAAO,CAAC,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,iBAAiB,IAAI,GAAG,CAAC;AACtE,CAAC;AACD,iGAAiG;AACjG,mDAAmD;AACnD,+CAA+C;AAC/C,SAAS,qCAAqC,CAAC,IAAY,EAAE,KAAU;IACrE,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;AACpE,CAAC;AACD,+CAA+C;AAC/C,SAAS,8BAA8B,CACrC,YAAoB;AACpB,sFAAsF;AACtF,oBAGY;IAEZ,MAAM,cAAc,GAAG,oBAAoB,IAAI,qBAAqB,CAAC;IACrE,OAAO,SAAS,8BAA8B,CAC5C,IAA4B,EAC5B,QAAgB,EAChB,QAA8B,EAC9B,aAAkC,EAAE;QAEpC,IAAI,KAAuB,CAAC;QAE5B,mEAAmE;QACnE,MAAM,YAAY,GAAG,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;YAC1C,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC;YACnC,CAAC,CAAC,QAAQ,CAAC;QAEb,IAAI,CAAC;YACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAqB,CAAC;QACvD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAA,qBAAY,EAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QACjD,CAAC;QAED,8EAA8E;QAC9E,MAAM,KAAK,GACT,MAAM,CAAC,MAAM,CACX,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CACpC,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,IAAI,KAAK,QAAQ,CAAC,cAAc,CACtD,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CACb,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,GAAG,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;QAC/C,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,IAAI,eAAe,CACxB,eACE,QAAQ,CAAC,cACX,oBAAoB,IAAI,CAAC,SAAS,CAChC,UAAU,EACV,qCAAqC,CACtC;QACD,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,IACtC,QAAQ,CAAC,cACX,qBACE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAC9D,EAAE,EACF,IAAI,CACL,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,eAAe,CACxB,YAAY,QAAQ,CAAC,cAAc,oBAAoB,IAAI,CAAC,SAAS,CACnE,UAAU,EACV,qCAAqC,CACtC;QACD,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,IACtC,QAAQ,CAAC,cACX,qBACE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAC9D,EAAE,EACF,IAAI,CACL,CAAC;QACJ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,iCAAiC,CAC/C,oBAGY;IAEZ,OAAO,SAAS,8BAA8B,CAC5C,QAAgB,EAChB,YAAkC,EAClC,aAAkC,EAAE;QAEpC,OAAO,8BAA8B,CACnC,gCAAgC,EAChC,oBAAoB,CACrB,CAAC,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAChD,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,+BAA+B,CAC7C,oBAGY;IAEZ,OAAO,SAAS,4BAA4B,CAC1C,QAAgB,EAChB,YAAkC,EAClC,aAAkC,EAAE;QAEpC,OAAO,8BAA8B,CACnC,8BAA8B,EAC9B,oBAAoB,CACrB,CAAC,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IACpD,CAAC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,gBAAgB,GAAG,CAAC,GAAQ,EAAwC,EAAE,CAC1E,QAAQ,IAAI,GAAG;IACf,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;IACzB,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;AAEtD;;GAEG;AACH,MAAM,iBAAiB,GAAG,CAAC,WAAkB,EAAU,EAAE,CACvD,WAAW;KACR,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,IAAI,CAAC,EAAE,OAAO,CAAC;KACxC,GAAG,CACF,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,CAChC,GAAG,QAAQ,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAC1D;KACA,IAAI,CAAC,IAAI,CAAC,CAAC;AAEhB;;;;;GAKG;AACH,MAAM,qBAAqB,GAAG,CAAC,MAAc,EAAU,EAAE;IACvD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,CAAC;YACvC,OAAO,iBAAiB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;IAC3E,CAAC;IAED,MAAM,WAAW,GAAG,MAAM;SACvB,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACZ,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;SACD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,YAAY,IAAI,KAAK,CAAC,UAAU,CAAC;SACnE,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAEpC,OAAO,iBAAiB,CAAC,WAAW,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,iBAAiB,GAAG,CAAC,OAAe,EAAE,GAAY,EAAE,EAAE;IAC1D,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,OAAO,GAAG,OAAO,KAAK,GAAG,GAAG,CAAC;IAC/B,CAAC;IAED,MAAM,MAAM,GACV,GAAG,CAAC,MAAM;QACR,EAAE,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;SAClD,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IAEtB,2FAA2F;IAC3F,6EAA6E;IAC7E,MAAM,WAAW,GAAG,qBAAqB,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC9E,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM;QACjC,CAAC,CAAC,kBAAkB,WAAW,EAAE;QACjC,CAAC,CAAC,MAAM,CAAC,MAAM;YACb,CAAC,CAAC,aAAa,MAAM,EAAE;YACvB,CAAC,CAAC,EAAE,CAAC;IAET,OAAO,GAAG,OAAO,KAAK,GAAG,GAAG,QAAQ,GAAG,CAAC;AAC1C,CAAC,CAAC;AAEF;;;GAGG;AACH,SAAgB,+BAA+B,CAC7C,oBAGY;IAEZ,OAAO,SAAS,4BAA4B,CAC1C,QAAgB,EAChB,YAAkC,EAClC,aAAkC,EAAE;QAEpC,OAAO,8BAA8B,CACnC,8BAA8B,EAC9B,oBAAoB,CACrB,CAAC,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IACpD,CAAC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,4BAA4B;IACnC,OAAO,CACL,OAAO,CAAC,GAAG,CAAC,gCAAgC;QAC5C,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,kCAAkC,CAAC,CAC3D,CAAC;AACJ,CAAC;AAED,4FAA4F;AAC5F,wDAAwD;AACxD,MAAM,YAAY,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAEzC,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAkB,CAAC;AAErD,+CAA+C;AAC/C,SAAS,gBAAgB,CAAC,UAAkB,EAAE,GAAsB;IAClE,MAAM,MAAM,GAAG,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAClD,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,OAAO,GAAG,SAAS,CAAC;IACxB,IAAI,CAAC;QACH,OAAO,GAAG,IAAA,wBAAQ,EAAC,GAAG,UAAU,UAAU,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;aAChE,QAAQ,CAAC,MAAM,CAAC;aAChB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IAAC,MAAM,CAAC;QACP,0EAA0E;IAC5E,CAAC;IAED,kBAAkB,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC5C,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,+CAA+C;AAC/C,SAAS,uBAAuB,CAC9B,UAAkB,EAClB,UAAkB,EAClB,GAAsB;IAEtB,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CACvB,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,EAAE,MAAM,CAAC,CAC9D,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM;aACpB,UAAU,CAAC,QAAQ,CAAC;aACpB,MAAM,CAAC,UAAU,CAAC;aAClB,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;aACzC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,kBAAkB,IAAI,EAAE,CAAC,CAAC;aACnE,MAAM,CAAC,KAAK,CAAC,CAAC;QACjB,OAAO,IAAI,CAAC,IAAI,CAAC,4BAA4B,EAAE,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,+CAA+C;AAC/C,SAAS,qBAAqB,CAAC,cAAsB;IACnD,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,OAAO,GAAG,YAAY,CAAC;IACzE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CACxB,UAAkB,EAClB,UAAkB,EAClB,GAAsB;IAEtB,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAC;IACpE,IAAI,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;QAClC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,QAAQ,GAAG,uBAAuB,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;IAClE,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,EAAE,CAAC;QAC3C,OAAO,KAAK,CAAC;IACf,CAAC;IAED,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,kBAAkB,CAAC,GAAsB;IAChD,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,GAAG,GAAG,CAAC;IACtD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,+BAA+B,CACtC,UAAkB,EAClB,UAAkB,EAClB,GAAsB;IAEtB,MAAM,QAAQ,GAAG,uBAAuB,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO;IACT,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAC;IACpE,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;IAClE,MAAM,cAAc,GAAG,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IACrD,IAAI,CAAC,cAAc,IAAI,qBAAqB,CAAC,cAAc,CAAC,EAAE,CAAC;QAC7D,IAAI,CAAC;YACH,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;QAClD,CAAC;QAAC,MAAM,CAAC;YACP,8EAA8E;QAChF,CAAC;IACH,CAAC;IAED,IAAA,wBAAQ,EAAC,GAAG,UAAU,mCAAmC,EAAE;QACzD,GAAG,EAAE,UAAU;QACf,GAAG;QACH,KAAK,EAAE,MAAM;KACd,CAAC,CAAC;IAEH,IAAI,cAAc,EAAE,CAAC;QACnB,qFAAqF;QACrF,OAAO;IACT,CAAC;IAED,IAAI,CAAC;QACH,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5C,MAAM,WAAW,GAAG,GAAG,cAAc,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;QAC3D,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;QAC7C,EAAE,CAAC,UAAU,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;IAC7C,CAAC;IAAC,MAAM,CAAC;QACP,yFAAyF;IAC3F,CAAC;AACH,CAAC;AAED,+CAA+C;AAC/C,SAAS,iBAAiB,CACxB,QAAgB;IAEhB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE,MAAM,CAAC,CACjE,CAAC;IACF,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,2BAA2B,CAAC,QAAkB;IAC5D,QAAQ;SACL,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CACf,iBAAiB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CACvC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAC1C,CACF;SACA,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,CACtB,+BAA+B,CAC7B,UAAU,EACV,0BAAmB,EACnB,OAAO,CAAC,GAAG,CACZ,CACF,CAAC;AACN,CAAC;AAED,8FAA8F;AAC9F,sCAAsC;AACtC,MAAM,eAAe,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C;;GAEG;AACH,SAAgB,kBAAkB,CAAC,QAAgB;IACjD,IAAI,CAAC;QACH,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACzC,MAAM,IAAA,mCAA0B,EAAC,oBAAoB,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,IAAI,eAAe,CACxB,iDAAiD,CAAC,EAAE,EACpD,KAAK,CACN,CAAC;IACJ,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAE3C,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE;YAC/B,MAAM,IAAI,GAAG;gBACX,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC;gBACnD,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,KAAK,EAAE,MAAM;gBACb,SAAS,EAAE,eAAe;aACpB,CAAC;YACT,MAAM,MAAM,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAAG,EAAE,0BAAmB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;YAC1E,IAAA,wBAAQ,EAAC,GAAG,0BAAmB,mCAAmC,EAAE;gBAClE,GAAG,IAAI;gBACP,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC;aACtD,CAAC,CAAC;YACH,MAAM,GAAG,GAAG,IAAA,wBAAQ,EAAC,GAAG,0BAAmB,iBAAiB,EAAE,IAAI,CAAC,CAAC;YAEpE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC1C,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;gBAClB,MAAM,IAAA,mCAA0B,EAC9B,MAAM,CAAC,WAAW,EAClB,IAAI,EACJ,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAC9B,CAAC;YACJ,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,eAAe,CACxB,oDAAoD,EACpD,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,IAAI,eAAe,CACxB,iBAAiB,CAAC,gDAAgD,EAAE,CAAC,CAAC,EACtE,KAAK,CACN,CAAC;IACJ,CAAC;AACH,CAAC;AAYD,MAAM,6BAA6B,GACjC,2CAA2C,CAAC;AAE9C;;;;;GAKG;AACH,SAAS,wBAAwB,CAAC,UAAkB;IAClD,EAAE,CAAC,aAAa,CACd,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,6BAA6B,CAAC,EACpD,IAAI,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAC1D,CAAC;AACJ,CAAC;AAED,+CAA+C;AAC/C,SAAS,0BAA0B,CAAC,UAAkB;IACpD,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,6BAA6B,CAAC,EAAE;QAC9D,KAAK,EAAE,IAAI;KACZ,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAChC,QAAgB,EAChB,UAAqC,EAAE;IAEvC,MAAM,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;IAEnC,IAAI,CAAC;QACH,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACzC,MAAM,IAAA,mCAA0B,EAAC,oBAAoB,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,IAAI,eAAe,CACxB,iDAAiD,CAAC,EAAE,EACpD,KAAK,CACN,CAAC;IACJ,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAE3C,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE;YAC3B,MAAM,IAAI,GAAG;gBACX,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC;gBACnD,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,KAAK,EAAE,MAAM;gBACb,SAAS,EAAE,eAAe;aACpB,CAAC;YAET,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,wBAAwB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrC,CAAC;YAED,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,iBAAiB,CAC9B,IAAI,CAAC,GAAG,EACR,0BAAmB,EACnB,IAAI,CAAC,GAAG,CACT,CAAC;gBACF,IAAA,wBAAQ,EAAC,GAAG,0BAAmB,oBAAoB,EAAE;oBACnD,GAAG,IAAI;oBACP,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC;iBACtD,CAAC,CAAC;gBAEH,iCAAiC;gBACjC,IAAA,wBAAQ,EACN,GAAG,0BAAmB,sCAAsC,EAC5D,IAAI,CACL,CAAC;YACJ,CAAC;oBAAS,CAAC;gBACT,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,0BAA0B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,eAAe,CACxB,2CAA2C,EAC3C,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,IAAI,eAAe,CACxB,iBAAiB,CAAC,uCAAuC,EAAE,CAAC,CAAC,EAC7D,KAAK,CACN,CAAC;IACJ,CAAC;AACH,CAAC","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"]}
|