@pact-foundation/pact-core
Version:
Core of @pact-foundation/pact. You almost certainly don't want to depend on this directly.
226 lines • 9.48 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateOptions = exports.validationRules = exports.requiresOneOf = exports.requires = exports.incompatibleWith = exports.deprecatedBy = exports.deprecatedFunction = void 0;
const checkTypes = require("check-types");
const underscore_1 = require("underscore");
const logger_1 = __importStar(require("../logger"));
const deprecatedFunction = () => (_, property) => {
logger_1.default.warn(`${property} is deprecated and no longer has any effect`);
return true;
};
exports.deprecatedFunction = deprecatedFunction;
const deprecatedBy = (preferredOption) => () => (_, property) => {
logger_1.default.warn(`${property} is deprecated, use ${preferredOption} instead`);
return true;
};
exports.deprecatedBy = deprecatedBy;
const incompatibleWith = (keys) => (options) => (_, property) => {
const incompatibilities = (0, underscore_1.pick)(options, keys);
if (Object.keys(incompatibilities).length > 0) {
(0, logger_1.logErrorAndThrow)(`${property} is incompatible with the following properties: ${keys.join(',')}`);
return false;
}
return true;
};
exports.incompatibleWith = incompatibleWith;
const requires = (keys) => (options) => (_, property) => {
const required = (0, underscore_1.pick)(options, keys);
if (keys.length !== Object.keys(required).length) {
(0, logger_1.logErrorAndThrow)(`${property} requires the following properties: ${keys.join(',')}`);
return false;
}
return true;
};
exports.requires = requires;
const requiresOneOf = (keys) => (options) => (_, property) => {
const required = (0, underscore_1.pick)(options, keys);
if (Object.keys(required).length === 0) {
(0, logger_1.logErrorAndThrow)(`${property} requires one of the following properties: ${keys.join(',')}`);
return false;
}
return true;
};
exports.requiresOneOf = requiresOneOf;
const assertNonEmptyString = () => (a, property) => checkTypes.assert.nonEmptyString(a, property);
const assertBoolean = () => (a, property) => checkTypes.assert.boolean(a, property);
const assertPositive = () => (a, property) => checkTypes.assert.positive(a, property);
const LogLevels = ['debug', 'error', 'info', 'trace', 'warn'];
const logLevelValidator = () => (l) => {
if (typeof l === 'string') {
if (LogLevels.includes(l.toLowerCase())) {
return true;
}
}
throw new Error(`The logLevel '${l}' is not a valid logLevel. The valid options are: ${LogLevels.join(', ')}`);
};
const consumerVersionSelectorValidator = (options) => () => {
if (options.consumerVersionSelectors &&
Array.isArray(options.consumerVersionSelectors)) {
const PROPS = [
'tag',
'latest',
'consumer',
'deployedOrReleased',
'deployed',
'released',
'environment',
'fallbackTag',
'branch',
'mainBranch',
'matchingBranch',
];
options.consumerVersionSelectors.forEach((selector) => {
if (selector.tag === 'latest') {
logger_1.default.warn("Using the tag 'latest' is not recommended and probably does not do what you intended.");
logger_1.default.warn(' See https://docs.pact.io/pact_broker/tags/#latest-pacts');
logger_1.default.warn(' If you need to specify latest, try:');
logger_1.default.warn(' consumerVersionSelectors: [{ lastest: true }]');
}
Object.keys(selector).forEach((key) => {
if (!PROPS.includes(key)) {
logger_1.default.warn(`The consumer version selector '${key}' is unknown but will be sent through to the validation. Allowed properties are ${PROPS.join(', ')})`);
}
});
});
}
return true;
};
const consumerVersionTagsValidator = (options) => () => {
if (options.consumerVersionTags) {
if (!checkTypes.string(options.consumerVersionTags) &&
!checkTypes.array.of.string(options.consumerVersionTags)) {
throw new Error('consumerVersionTags should be a string or an array of strings');
}
if (options.consumerVersionTags.includes('latest')) {
logger_1.default.warn("Using the tag 'latest' is not recommended and probably does not do what you intended.");
logger_1.default.warn(' See https://docs.pact.io/pact_broker/tags/#latest-pacts');
logger_1.default.warn(' If you need to specify latest, try:');
logger_1.default.warn(' consumerVersionSelectors: [{ lastest: true }]');
}
}
return true;
};
const customProviderHeadersValidator = (options) => () => {
if (options.customProviderHeaders) {
if (Array.isArray(options.customProviderHeaders)) {
checkTypes.assert.array.of.string(options.customProviderHeaders);
}
else {
checkTypes.assert.nonEmptyObject(options.customProviderHeaders);
}
}
return true;
};
exports.validationRules = {
providerBaseUrl: [assertNonEmptyString],
buildUrl: [assertNonEmptyString],
consumerVersionSelectors: [consumerVersionSelectorValidator],
consumerVersionTags: [consumerVersionTagsValidator],
customProviderHeaders: [customProviderHeadersValidator],
disableSslVerification: [assertBoolean],
enablePending: [assertBoolean],
format: [exports.deprecatedFunction],
includeWipPactsSince: [assertNonEmptyString],
provider: [assertNonEmptyString],
pactUrls: [assertNonEmptyString],
pactBrokerUrl: [
assertNonEmptyString,
(0, exports.requires)(['provider']),
(0, exports.requiresOneOf)([
'pactUrls',
'consumerVersionSelectors',
'consumerVersionTags',
]),
],
pactBrokerUsername: [
assertNonEmptyString,
(0, exports.incompatibleWith)(['pactBrokerToken']),
(0, exports.requires)(['pactBrokerPassword']),
],
pactBrokerPassword: [
assertNonEmptyString,
(0, exports.incompatibleWith)(['pactBrokerToken']),
(0, exports.requires)(['pactBrokerUsername']),
],
pactBrokerToken: [
assertNonEmptyString,
(0, exports.incompatibleWith)(['pactBrokerUsername', 'pactBrokerPassword']),
],
providerVersionTags: [assertNonEmptyString],
providerBranch: [
assertNonEmptyString,
(0, exports.deprecatedBy)('providerVersionBranch'),
],
providerVersionBranch: [assertNonEmptyString],
providerStatesSetupUrl: [assertNonEmptyString],
providerStatesSetupTeardown: [assertBoolean],
providerStatesSetupBody: [assertBoolean],
publishVerificationResult: [assertBoolean, (0, exports.requires)(['providerVersion'])],
providerVersion: [assertNonEmptyString],
timeout: [assertPositive],
logLevel: [logLevelValidator],
out: [exports.deprecatedFunction],
verbose: [exports.deprecatedFunction],
monkeypatch: [exports.deprecatedFunction],
logDir: [exports.deprecatedFunction],
logFile: [assertNonEmptyString],
consumerFilters: [assertNonEmptyString],
failIfNoPactsFound: [assertBoolean],
transports: [],
};
const validateOptions = (options) => {
if (!options.pactUrls && !options.providerBaseUrl) {
throw new Error('Either pactUrls or providerBaseUrl must be provided');
}
Object.keys(options).concat('providerBaseUrl').forEach((k) => {
const rules = exports.validationRules[k];
if (k in options && Array.isArray(options[k])) {
options[k].forEach((item) => {
(rules || []).forEach((rule) => {
rule(options)(item, k);
});
});
}
else if (k in options) {
(rules || []).forEach((rule) => {
rule(options)(options[k], k);
});
}
});
return options;
};
exports.validateOptions = validateOptions;
//# sourceMappingURL=validateOptions.js.map