@itentialopensource/adapter-hashicorp_vault
Version:
This adapter integrates with system described as: hashicorp_vault.
22,448 lines • 838 kB
JavaScript
/* @copyright Itential, LLC 2019 (pre-modifications) */
// Set globals
/* global describe it log pronghornProps */
/* eslint no-unused-vars: warn */
/* eslint no-underscore-dangle: warn */
/* eslint import/no-dynamic-require:warn */
// include required items for testing & logging
const assert = require('assert');
const fs = require('fs');
const path = require('path');
const util = require('util');
const mocha = require('mocha');
const winston = require('winston');
const { expect } = require('chai');
const { use } = require('chai');
const td = require('testdouble');
const anything = td.matchers.anything();
// stub and attemptTimeout are used throughout the code so set them here
let logLevel = 'none';
const isRapidFail = false;
const isSaveMockData = false;
// read in the properties from the sampleProperties files
let adaptdir = __dirname;
if (adaptdir.endsWith('/test/integration')) {
adaptdir = adaptdir.substring(0, adaptdir.length - 17);
} else if (adaptdir.endsWith('/test/unit')) {
adaptdir = adaptdir.substring(0, adaptdir.length - 10);
}
const samProps = require(`${adaptdir}/sampleProperties.json`).properties;
// these variables can be changed to run in integrated mode so easier to set them here
// always check these in with bogus data!!!
samProps.stub = true;
// uncomment if connecting
// samProps.host = 'replace.hostorip.here';
// samProps.authentication.username = 'username';
// samProps.authentication.password = 'password';
// samProps.authentication.token = 'password';
// samProps.protocol = 'http';
// samProps.port = 80;
// samProps.ssl.enabled = false;
// samProps.ssl.accept_invalid_cert = false;
if (samProps.request.attempt_timeout < 30000) {
samProps.request.attempt_timeout = 30000;
}
samProps.devicebroker.enabled = true;
const attemptTimeout = samProps.request.attempt_timeout;
const { stub } = samProps;
// these are the adapter properties. You generally should not need to alter
// any of these after they are initially set up
global.pronghornProps = {
pathProps: {
encrypted: false
},
adapterProps: {
adapters: [{
id: 'Test-hashicorp_vault',
type: 'HashiCorpVault',
properties: samProps
}]
}
};
global.$HOME = `${__dirname}/../..`;
// set the log levels that Pronghorn uses, spam and trace are not defaulted in so without
// this you may error on log.trace calls.
const myCustomLevels = {
levels: {
spam: 6,
trace: 5,
debug: 4,
info: 3,
warn: 2,
error: 1,
none: 0
}
};
// need to see if there is a log level passed in
process.argv.forEach((val) => {
// is there a log level defined to be passed in?
if (val.indexOf('--LOG') === 0) {
// get the desired log level
const inputVal = val.split('=')[1];
// validate the log level is supported, if so set it
if (Object.hasOwnProperty.call(myCustomLevels.levels, inputVal)) {
logLevel = inputVal;
}
}
});
// need to set global logging
global.log = winston.createLogger({
level: logLevel,
levels: myCustomLevels.levels,
transports: [
new winston.transports.Console()
]
});
/**
* Runs the common asserts for test
*/
function runCommonAsserts(data, error) {
assert.equal(undefined, error);
assert.notEqual(undefined, data);
assert.notEqual(null, data);
assert.notEqual(undefined, data.response);
assert.notEqual(null, data.response);
}
/**
* Runs the error asserts for the test
*/
function runErrorAsserts(data, error, code, origin, displayStr) {
assert.equal(null, data);
assert.notEqual(undefined, error);
assert.notEqual(null, error);
assert.notEqual(undefined, error.IAPerror);
assert.notEqual(null, error.IAPerror);
assert.notEqual(undefined, error.IAPerror.displayString);
assert.notEqual(null, error.IAPerror.displayString);
assert.equal(code, error.icode);
assert.equal(origin, error.IAPerror.origin);
assert.equal(displayStr, error.IAPerror.displayString);
}
/**
* @function saveMockData
* Attempts to take data from responses and place them in MockDataFiles to help create Mockdata.
* Note, this was built based on entity file structure for Adapter-Engine 1.6.x
* @param {string} entityName - Name of the entity saving mock data for
* @param {string} actionName - Name of the action saving mock data for
* @param {string} descriptor - Something to describe this test (used as a type)
* @param {string or object} responseData - The data to put in the mock file.
*/
function saveMockData(entityName, actionName, descriptor, responseData) {
// do not need to save mockdata if we are running in stub mode (already has mock data) or if told not to save
if (stub || !isSaveMockData) {
return false;
}
// must have a response in order to store the response
if (responseData && responseData.response) {
let data = responseData.response;
// if there was a raw response that one is better as it is untranslated
if (responseData.raw) {
data = responseData.raw;
try {
const temp = JSON.parse(data);
data = temp;
} catch (pex) {
// do not care if it did not parse as we will just use data
}
}
try {
const base = path.join(__dirname, `../../entities/${entityName}/`);
const mockdatafolder = 'mockdatafiles';
const filename = `mockdatafiles/${actionName}-${descriptor}.json`;
if (!fs.existsSync(base + mockdatafolder)) {
fs.mkdirSync(base + mockdatafolder);
}
// write the data we retrieved
fs.writeFile(base + filename, JSON.stringify(data, null, 2), 'utf8', (errWritingMock) => {
if (errWritingMock) throw errWritingMock;
// update the action file to reflect the changes. Note: We're replacing the default object for now!
fs.readFile(`${base}action.json`, (errRead, content) => {
if (errRead) throw errRead;
// parse the action file into JSON
const parsedJson = JSON.parse(content);
// The object update we'll write in.
const responseObj = {
type: descriptor,
key: '',
mockFile: filename
};
// get the object for method we're trying to change.
const currentMethodAction = parsedJson.actions.find((obj) => obj.name === actionName);
// if the method was not found - should never happen but...
if (!currentMethodAction) {
throw Error('Can\'t find an action for this method in the provided entity.');
}
// if there is a response object, we want to replace the Response object. Otherwise we'll create one.
const actionResponseObj = currentMethodAction.responseObjects.find((obj) => obj.type === descriptor);
// Add the action responseObj back into the array of response objects.
if (!actionResponseObj) {
// if there is a default response object, we want to get the key.
const defaultResponseObj = currentMethodAction.responseObjects.find((obj) => obj.type === 'default');
// save the default key into the new response object
if (defaultResponseObj) {
responseObj.key = defaultResponseObj.key;
}
// save the new response object
currentMethodAction.responseObjects = [responseObj];
} else {
// update the location of the mock data file
actionResponseObj.mockFile = responseObj.mockFile;
}
// Save results
fs.writeFile(`${base}action.json`, JSON.stringify(parsedJson, null, 2), (err) => {
if (err) throw err;
});
});
});
} catch (e) {
log.debug(`Failed to save mock data for ${actionName}. ${e.message}`);
return false;
}
}
// no response to save
log.debug(`No data passed to save into mockdata for ${actionName}`);
return false;
}
// require the adapter that we are going to be using
const HashiCorpVault = require('../../adapter');
// begin the testing - these should be pretty well defined between the describe and the it!
describe('[integration] HashiCorpVault Adapter Test', () => {
describe('HashiCorpVault Class Tests', () => {
const a = new HashiCorpVault(
pronghornProps.adapterProps.adapters[0].id,
pronghornProps.adapterProps.adapters[0].properties
);
if (isRapidFail) {
const state = {};
state.passed = true;
mocha.afterEach(function x() {
state.passed = state.passed
&& (this.currentTest.state === 'passed');
});
mocha.beforeEach(function x() {
if (!state.passed) {
return this.currentTest.skip();
}
return true;
});
}
describe('#class instance created', () => {
it('should be a class with properties', (done) => {
try {
assert.notEqual(null, a);
assert.notEqual(undefined, a);
const checkId = global.pronghornProps.adapterProps.adapters[0].id;
assert.equal(checkId, a.id);
assert.notEqual(null, a.allProps);
const check = global.pronghornProps.adapterProps.adapters[0].properties.healthcheck.type;
assert.equal(check, a.healthcheckType);
done();
} catch (error) {
log.error(`Test Failure: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#connect', () => {
it('should get connected - no healthcheck', (done) => {
try {
a.healthcheckType = 'none';
a.connect();
try {
assert.equal(true, a.alive);
done();
} catch (error) {
log.error(`Test Failure: ${error}`);
done(error);
}
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
});
it('should get connected - startup healthcheck', (done) => {
try {
a.healthcheckType = 'startup';
a.connect();
try {
assert.equal(true, a.alive);
done();
} catch (error) {
log.error(`Test Failure: ${error}`);
done(error);
}
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
});
});
describe('#healthCheck', () => {
it('should be healthy', (done) => {
try {
a.healthCheck(null, (data) => {
try {
assert.equal(true, a.healthy);
saveMockData('system', 'healthcheck', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
// broker tests
describe('#getDevicesFiltered - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
const opts = {
filter: {
name: 'deviceName'
}
};
a.getDevicesFiltered(opts, (data, error) => {
try {
if (stub) {
if (samProps.devicebroker.getDevicesFiltered[0].handleFailure === 'ignore') {
assert.equal(null, error);
assert.notEqual(undefined, data);
assert.notEqual(null, data);
assert.equal(0, data.total);
assert.equal(0, data.list.length);
} else {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
}
} else {
runCommonAsserts(data, error);
}
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#iapGetDeviceCount - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
const opts = {
filter: {
name: 'deviceName'
}
};
a.iapGetDeviceCount((data, error) => {
try {
if (stub) {
if (samProps.devicebroker.getDevicesFiltered[0].handleFailure === 'ignore') {
assert.equal(null, error);
assert.notEqual(undefined, data);
assert.notEqual(null, data);
assert.equal(0, data.count);
} else {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
}
} else {
runCommonAsserts(data, error);
}
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
// exposed cache tests
describe('#iapPopulateEntityCache - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.iapPopulateEntityCache('Device', (data, error) => {
try {
if (stub) {
assert.equal(null, data);
assert.notEqual(undefined, error);
assert.notEqual(null, error);
done();
} else {
assert.equal(undefined, error);
assert.equal('success', data[0]);
done();
}
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#iapRetrieveEntitiesCache - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.iapRetrieveEntitiesCache('Device', {}, (data, error) => {
try {
if (stub) {
assert.equal(null, data);
assert.notEqual(null, error);
assert.notEqual(undefined, error);
} else {
assert.equal(undefined, error);
assert.notEqual(null, data);
assert.notEqual(undefined, data);
}
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
/*
-----------------------------------------------------------------------
-----------------------------------------------------------------------
*** All code above this comment will be replaced during a migration ***
******************* DO NOT REMOVE THIS COMMENT BLOCK ******************
-----------------------------------------------------------------------
-----------------------------------------------------------------------
*/
const secretsPostSecretConfigBodyParam = {
cas_required: true,
delete_version_after: 6,
max_versions: 8
};
describe('#postKvSecretConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvSecretConfig('namespace', 'mount', secretsPostSecretConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvSecretConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPathParam = 'fakedata';
const secretsPostSecretDataPathBodyParam = {
data: {},
options: {},
version: 2
};
describe('#postKvSecretDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvSecretDataPath('namespace', 'mount', secretsPathParam, secretsPostSecretDataPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvSecretDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretDeletePathBodyParam = {
versions: [
3
]
};
describe('#postKvSecretDeletePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvSecretDeletePath('namespace', 'mount', secretsPathParam, secretsPostSecretDeletePathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvSecretDeletePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretDestroyPathBodyParam = {
versions: [
6
]
};
describe('#postKvSecretDestroyPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvSecretDestroyPath('namespace', 'mount', secretsPathParam, secretsPostSecretDestroyPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvSecretDestroyPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretMetadataPathBodyParam = {
cas_required: false,
delete_version_after: 9,
max_versions: 6
};
describe('#postKvSecretMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvSecretMetadataPath('namespace', 'mount', secretsPathParam, secretsPostSecretMetadataPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvSecretMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretUndeletePathBodyParam = {
versions: [
8
]
};
describe('#postKvSecretUndeletePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvSecretUndeletePath('namespace', 'mount', secretsPathParam, secretsPostSecretUndeletePathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvSecretUndeletePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postCubbyholeSecretPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCubbyholeSecretPath('namespace', 'mount', secretsPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCubbyholeSecretPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretConfigCaBodyParam = {
pem_bundle: 'string'
};
describe('#postPkiSecretConfigCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretConfigCa('namespace', 'mount', secretsPostSecretConfigCaBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretConfigCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretConfigCrlBodyParam = {
disable: false,
expiry: '72h'
};
describe('#postPkiSecretConfigCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretConfigCrl('namespace', 'mount', secretsPostSecretConfigCrlBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretConfigCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretConfigUrlsBodyParam = {
crl_distribution_points: [
'string'
],
issuing_certificates: [
'string'
],
ocsp_servers: [
'string'
]
};
describe('#postPkiSecretConfigUrls - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretConfigUrls('namespace', 'mount', secretsPostSecretConfigUrlsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretConfigUrls', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsExported = 'fakedata';
const secretsPostSecretIntermediateGenerateExportedBodyParam = {
add_basic_constraints: true,
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
exclude_cn_from_sans: false,
format: 'pem',
ip_sans: [
'string'
],
key_bits: 2048,
key_type: 'rsa',
locality: [
'string'
],
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 10,
uri_sans: [
'string'
]
};
describe('#postPkiSecretGenerateIntermediate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretGenerateIntermediate('namespace', 'mount', secretsExported, secretsPostSecretIntermediateGenerateExportedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretGenerateIntermediate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretIntermediateSetSignedBodyParam = {
certificate: 'string'
};
describe('#postPkiSecretSetSignedIntermediate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretSetSignedIntermediate('namespace', 'mount', secretsPostSecretIntermediateSetSignedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretSetSignedIntermediate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsRole = 'fakedata';
const secretsPostSecretIssueRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
exclude_cn_from_sans: false,
format: 'pem',
ip_sans: [
'string'
],
other_sans: [
'string'
],
private_key_format: 'der',
serial_number: 'string',
ttl: 3,
uri_sans: [
'string'
]
};
describe('#postPkiSecretIssueCert - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretIssueCert('namespace', 'mount', secretsRole, secretsPostSecretIssueRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretIssueCert', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretRevokeBodyParam = {
serial_number: 'string'
};
describe('#postPkiSecretRevokeCert - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretRevokeCert('namespace', 'mount', secretsPostSecretRevokeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretRevokeCert', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsName = 'fakedata';
const secretsPostSecretRolesNameBodyParam = {
allow_any_name: true,
allow_bare_domains: false,
allow_glob_domains: true,
allow_ip_sans: true,
allow_localhost: true,
allow_subdomains: true,
allowed_domains: [
'string'
],
allowed_domains_template: false,
allowed_other_sans: [
'string'
],
allowed_serial_numbers: [
'string'
],
allowed_uri_sans: [
'string'
],
backend: 'string',
basic_constraints_valid_for_non_ca: false,
client_flag: true,
code_signing_flag: false,
country: [
'string'
],
email_protection_flag: true,
enforce_hostnames: true,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
generate_lease: true,
key_bits: 2048,
key_type: 'rsa',
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
locality: [
'string'
],
max_ttl: 5,
no_store: false,
not_before_duration: 30,
organization: [
'string'
],
ou: [
'string'
],
policy_identifiers: [
'string'
],
postal_code: [
'string'
],
province: [
'string'
],
require_cn: true,
server_flag: true,
street_address: [
'string'
],
ttl: 7,
use_csr_common_name: true,
use_csr_sans: true
};
describe('#postPkiSecretRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretRolesName('namespace', 'mount', secretsName, secretsPostSecretRolesNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretRootGenerateExportedBodyParam = {
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
exclude_cn_from_sans: true,
format: 'pem',
ip_sans: [
'string'
],
key_bits: 2048,
key_type: 'rsa',
locality: [
'string'
],
max_path_length: -1,
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
permitted_dns_domains: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 6,
uri_sans: [
'string'
]
};
describe('#postPkiSecretGenerateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretGenerateRoot('namespace', 'mount', secretsExported, secretsPostSecretRootGenerateExportedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretGenerateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretRootSignIntermediateBodyParam = {
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
csr: 'string',
exclude_cn_from_sans: true,
format: 'pem',
ip_sans: [
'string'
],
locality: [
'string'
],
max_path_length: -1,
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
permitted_dns_domains: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 1,
uri_sans: [
'string'
],
use_csr_values: false
};
describe('#postPkiSecretSignIntermediateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretSignIntermediateRoot('namespace', 'mount', secretsPostSecretRootSignIntermediateBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretSignIntermediateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretRootSignSelfIssuedBodyParam = {
certificate: 'string'
};
describe('#postPkiSecretRootSignSelfIssued - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretRootSignSelfIssued('namespace', 'mount', secretsPostSecretRootSignSelfIssuedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretRootSignSelfIssued', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretSignVerbatimBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: false,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
format: 'pem',
ip_sans: [
'string'
],
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
other_sans: [
'string'
],
private_key_format: 'der',
role: 'string',
serial_number: 'string',
ttl: 4,
uri_sans: [
'string'
]
};
describe('#postPkiSecretSignVerbatim - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretSignVerbatim('namespace', 'mount', secretsPostSecretSignVerbatimBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretSignVerbatim', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretSignVerbatimRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: false,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
format: 'pem',
ip_sans: [
'string'
],
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
other_sans: [
'string'
],
private_key_format: 'der',
serial_number: 'string',
ttl: 8,
uri_sans: [
'string'
]
};
describe('#postPkiSecretSignVerbatimName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretSignVerbatimName('namespace', 'mount', secretsRole, secretsPostSecretSignVerbatimRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretSignVerbatimName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretSignRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: false,
format: 'pem',
ip_sans: [
'string'
],
other_sans: [
'string'
],
private_key_format: 'der',
serial_number: 'string',
ttl: 4,
uri_sans: [
'string'
]
};
describe('#postPkiSecretSignRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretSignRole('namespace', 'mount', secretsRole, secretsPostSecretSignRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretSignRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretTidyBodyParam = {
safety_buffer: 259200,
tidy_cert_store: false,
tidy_revocation_list: false,
tidy_revoked_certs: false
};
describe('#postPkiSecretTidy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSecretTidy('namespace', 'mount', secretsPostSecretTidyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSecretTidy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getKvSecretConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getKvSecretConfig('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getKvSecretConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getKvSecretDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getKvSecretDataPath('namespace', 'mount', secretsPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getKvSecretDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getKvSecretMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getKvSecretMetadataPath('namespace', 'mount', secretsPathParam, null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getKvSecretMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCubbyholeSecretPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCubbyholeSecretPath('namespace', 'mount', secretsPathParam, null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCubbyholeSecretPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCa('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCaPem - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCaPem('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCaPem', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCaChain - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCaChain('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCaChain', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCertCaChain - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCertCaChain('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCertCaChain', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCertCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCertCrl('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCertCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsSerial = 'fakedata';
describe('#getPkiSecretCertSerial - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCertSerial('namespace', 'mount', secretsSerial, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCertSerial', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCerts - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCerts('namespace', 'mount', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCerts', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretConfigCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretConfigCrl('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretConfigCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretConfigUrls - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretConfigUrls('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretConfigUrls', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCrl('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCrlPem - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCrlPem('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCrlPem', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretCrlRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretCrlRotate('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretCrlRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#listPkiSecretRoles - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.listPkiSecretRoles('namespace', 'mount', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'listPkiSecretRoles', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiSecretRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiSecretRolesName('namespace', 'mount', secretsName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiSecretRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleLoginBodyParam = {
role_id: 'string',
secret_id: 'string'
};
describe('#postAuthApproleLogin - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleLogin(authPostAuthApproleLoginBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleLogin', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authRoleName = 'fakedata';
const authPostAuthApproleRoleRoleNameBodyParam = {
bind_secret_id: true,
bound_cidr_list: [
'string'
],
local_secret_ids: true,
period: 1,
policies: [
'string'
],
role_id: 'string',
secret_id_bound_cidrs: [
'string'
],
secret_id_num_uses: 9,
secret_id_ttl: 6,
token_bound_cidrs: [
'string'
],
token_explicit_max_ttl: 7,
token_max_ttl: 10,
token_no_default_policy: true,
token_num_uses: 2,
token_period: 9,
token_policies: [
'string'
],
token_ttl: 8,
token_type: 'default-service'
};
describe('#postAuthApproleRoleRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleName(authRoleName, authPostAuthApproleRoleRoleNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameBindSecretIdBodyParam = {
bind_secret_id: true
};
describe('#postAuthApproleRoleRoleNameBindSecretId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameBindSecretId(authRoleName, authPostAuthApproleRoleRoleNameBindSecretIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameBindSecretId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameBoundCidrListBodyParam = {
bound_cidr_list: [
'string'
]
};
describe('#postAuthApproleRoleRoleNameBoundCidrList - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameBoundCidrList(authRoleName, authPostAuthApproleRoleRoleNameBoundCidrListBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameBoundCidrList', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameCustomSecretIdBodyParam = {
cidr_list: [
'string'
],
metadata: 'string',
secret_id: 'string',
token_bound_cidrs: [
'string'
]
};
describe('#postAuthApproleRoleRoleNameCustomSecretId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameCustomSecretId(authRoleName, authPostAuthApproleRoleRoleNameCustomSecretIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameCustomSecretId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNamePeriodBodyParam = {
period: 9,
token_period: 3
};
describe('#postAuthApproleRoleRoleNamePeriod - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNamePeriod(authRoleName, authPostAuthApproleRoleRoleNamePeriodBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNamePeriod', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNamePoliciesBodyParam = {
policies: [
'string'
],
token_policies: [
'string'
]
};
describe('#postAuthApproleRoleRoleNamePolicies - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNamePolicies(authRoleName, authPostAuthApproleRoleRoleNamePoliciesBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNamePolicies', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameRoleIdBodyParam = {
role_id: 'string'
};
describe('#postAuthApproleRoleRoleNameRoleId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameRoleId(authRoleName, authPostAuthApproleRoleRoleNameRoleIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameRoleId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdBodyParam = {
cidr_list: [
'string'
],
metadata: 'string',
token_bound_cidrs: [
'string'
]
};
describe('#postAuthApproleRoleRoleNameSecretId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretId(authRoleName, authPostAuthApproleRoleRoleNameSecretIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdAccessorDestroyBodyParam = {
secret_id_accessor: 'string'
};
describe('#postAuthApproleRoleRoleNameSecretIdAccessorDestroy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretIdAccessorDestroy(authRoleName, authPostAuthApproleRoleRoleNameSecretIdAccessorDestroyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretIdAccessorDestroy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdAccessorLookupBodyParam = {
secret_id_accessor: 'string'
};
describe('#postAuthApproleRoleRoleNameSecretIdAccessorLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretIdAccessorLookup(authRoleName, authPostAuthApproleRoleRoleNameSecretIdAccessorLookupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretIdAccessorLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdBoundCidrsBodyParam = {
secret_id_bound_cidrs: [
'string'
]
};
describe('#postAuthApproleRoleRoleNameSecretIdBoundCidrs - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretIdBoundCidrs(authRoleName, authPostAuthApproleRoleRoleNameSecretIdBoundCidrsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretIdBoundCidrs', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdNumUsesBodyParam = {
secret_id_num_uses: 2
};
describe('#postAuthApproleRoleRoleNameSecretIdNumUses - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretIdNumUses(authRoleName, authPostAuthApproleRoleRoleNameSecretIdNumUsesBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretIdNumUses', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdTtlBodyParam = {
secret_id_ttl: 8
};
describe('#postAuthApproleRoleRoleNameSecretIdTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretIdTtl(authRoleName, authPostAuthApproleRoleRoleNameSecretIdTtlBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretIdTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdDestroyBodyParam = {
secret_id: 'string'
};
describe('#postAuthApproleRoleRoleNameSecretIdDestroy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretIdDestroy(authRoleName, authPostAuthApproleRoleRoleNameSecretIdDestroyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretIdDestroy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameSecretIdLookupBodyParam = {
secret_id: 'string'
};
describe('#postAuthApproleRoleRoleNameSecretIdLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameSecretIdLookup(authRoleName, authPostAuthApproleRoleRoleNameSecretIdLookupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameSecretIdLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameTokenBoundCidrsBodyParam = {
token_bound_cidrs: [
'string'
]
};
describe('#postAuthApproleRoleRoleNameTokenBoundCidrs - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameTokenBoundCidrs(authRoleName, authPostAuthApproleRoleRoleNameTokenBoundCidrsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameTokenBoundCidrs', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameTokenMaxTtlBodyParam = {
token_max_ttl: 9
};
describe('#postAuthApproleRoleRoleNameTokenMaxTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameTokenMaxTtl(authRoleName, authPostAuthApproleRoleRoleNameTokenMaxTtlBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameTokenMaxTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameTokenNumUsesBodyParam = {
token_num_uses: 5
};
describe('#postAuthApproleRoleRoleNameTokenNumUses - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameTokenNumUses(authRoleName, authPostAuthApproleRoleRoleNameTokenNumUsesBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameTokenNumUses', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthApproleRoleRoleNameTokenTtlBodyParam = {
token_ttl: 1
};
describe('#postAuthApproleRoleRoleNameTokenTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleRoleRoleNameTokenTtl(authRoleName, authPostAuthApproleRoleRoleNameTokenTtlBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleRoleRoleNameTokenTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAuthApproleTidySecretId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthApproleTidySecretId((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthApproleTidySecretId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthLdapConfigBodyParam = {
anonymous_group_search: false,
binddn: 'string',
bindpass: 'string',
case_sensitive_names: true,
certificate: 'string',
client_tls_cert: 'string',
client_tls_key: 'string',
deny_null_bind: true,
discoverdn: false,
groupattr: 'cn',
groupdn: 'string',
groupfilter: '(|(memberUid={{.Username}})(member={{.UserDN}})(uniqueMember={{.UserDN}}))',
insecure_tls: false,
request_timeout: '90s',
starttls: true,
tls_max_version: 'tls12',
tls_min_version: 'tls12',
token_bound_cidrs: [
'string'
],
token_explicit_max_ttl: 6,
token_max_ttl: 1,
token_no_default_policy: false,
token_num_uses: 2,
token_period: 4,
token_policies: [
'string'
],
token_ttl: 10,
token_type: 'default-service',
upndomain: 'string',
url: 'ldap://127.0.0.1',
use_pre111_group_cn_behavior: false,
use_token_groups: true,
userattr: 'cn',
userdn: 'string'
};
describe('#postAuthLdapConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthLdapConfig(authPostAuthLdapConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthLdapConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthLdapDuoAccessBodyParam = {
host: 'string',
ikey: 'string',
skey: 'string'
};
describe('#postAuthLdapDuoAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthLdapDuoAccess(authPostAuthLdapDuoAccessBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthLdapDuoAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthLdapDuoConfigBodyParam = {
push_info: 'string',
user_agent: 'string',
username_format: 'string'
};
describe('#postAuthLdapDuoConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthLdapDuoConfig(authPostAuthLdapDuoConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthLdapDuoConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authName = 'fakedata';
const authPostAuthLdapGroupsNameBodyParam = {
policies: [
'string'
]
};
describe('#postAuthLdapGroupsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthLdapGroupsName(authName, authPostAuthLdapGroupsNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthLdapGroupsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authUsername = 'fakedata';
const authPostAuthLdapLoginUsernameBodyParam = {
method: 'string',
passcode: 'string',
password: 'string'
};
describe('#postAuthLdapLoginUsername - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthLdapLoginUsername(authUsername, authPostAuthLdapLoginUsernameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthLdapLoginUsername', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthLdapMfaConfigBodyParam = {
type: 'string'
};
describe('#postAuthLdapMfaConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthLdapMfaConfig(authPostAuthLdapMfaConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthLdapMfaConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthLdapUsersNameBodyParam = {
groups: [
'string'
],
policies: [
'string'
]
};
describe('#postAuthLdapUsersName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthLdapUsersName(authName, authPostAuthLdapUsersNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthLdapUsersName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthRancherConfigBodyParam = {
disable_iss_validation: true,
issuer: 'string',
kubernetes_ca_cert: 'string',
kubernetes_host: 'string',
pem_keys: [
'string'
],
token_reviewer_jwt: 'string'
};
describe('#postAuthRancherConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthRancherConfig(authPostAuthRancherConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthRancherConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthRancherLoginBodyParam = {
jwt: 'string',
role: 'string'
};
describe('#postAuthRancherLogin - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthRancherLogin(authPostAuthRancherLoginBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthRancherLogin', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthRancherRoleNameBodyParam = {
audience: 'string',
bound_cidrs: [
'string'
],
bound_service_account_names: [
'string'
],
bound_service_account_namespaces: [
'string'
],
max_ttl: 5,
num_uses: 4,
period: 3,
policies: [
'string'
],
token_bound_cidrs: [
'string'
],
token_explicit_max_ttl: 7,
token_max_ttl: 4,
token_no_default_policy: false,
token_num_uses: 1,
token_period: 1,
token_policies: [
'string'
],
token_ttl: 4,
token_type: 'default-service',
ttl: 7
};
describe('#postAuthRancherRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthRancherRoleName(authName, authPostAuthRancherRoleNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthRancherRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAuthTokenCreate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenCreate((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenCreate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAuthTokenCreateWithNamespaceHeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenCreateWithNamespaceHeader(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenCreate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAuthTokenCreateOrphan - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenCreateOrphan((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenCreateOrphan', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAuthTokenCreateRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenCreateRoleName(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenCreateRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenLookupBodyParam = {
token: 'string'
};
describe('#postAuthTokenLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenLookup(authPostAuthTokenLookupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenLookupAccessorBodyParam = {
accessor: 'string'
};
describe('#postAuthTokenLookupAccessor - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenLookupAccessor(authPostAuthTokenLookupAccessorBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenLookupAccessor', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenLookupSelfBodyParam = {
token: 'string'
};
describe('#postAuthTokenLookupSelf - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenLookupSelf(authPostAuthTokenLookupSelfBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenLookupSelf', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenRenewBodyParam = {
increment: 2,
token: 'string'
};
describe('#postAuthTokenRenew - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRenew(authPostAuthTokenRenewBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRenew', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenRenewAccessorBodyParam = {
accessor: 'string',
increment: 6
};
describe('#postAuthTokenRenewAccessor - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRenewAccessor(authPostAuthTokenRenewAccessorBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRenewAccessor', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenRenewSelfBodyParam = {
increment: 4,
token: 'string'
};
describe('#postAuthTokenRenewSelf - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRenewSelf(authPostAuthTokenRenewSelfBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRenewSelf', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenRevokeBodyParam = {
token: 'string'
};
describe('#postAuthTokenRevoke - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRevoke(authPostAuthTokenRevokeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRevoke', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenRevokeAccessorBodyParam = {
accessor: 'string'
};
describe('#postAuthTokenRevokeAccessor - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRevokeAccessor(authPostAuthTokenRevokeAccessorBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRevokeAccessor', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenRevokeOrphanBodyParam = {
token: 'string'
};
describe('#postAuthTokenRevokeOrphan - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRevokeOrphan(authPostAuthTokenRevokeOrphanBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRevokeOrphan', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAuthTokenRevokeSelf - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRevokeSelf((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRevokeSelf', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const authPostAuthTokenRolesRoleNameBodyParam = {
allowed_entity_aliases: [
'string'
],
allowed_policies: [
'string'
],
bound_cidrs: [
'string'
],
disallowed_policies: [
'string'
],
explicit_max_ttl: 1,
orphan: true,
path_suffix: 'string',
period: 5,
renewable: true,
token_bound_cidrs: [
'string'
],
token_explicit_max_ttl: 4,
token_no_default_policy: true,
token_num_uses: 10,
token_period: 1,
token_type: 'default-service'
};
describe('#postAuthTokenRolesRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenRolesRoleName(authRoleName, authPostAuthTokenRolesRoleNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenRolesRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAuthTokenTidy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAuthTokenTidy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'postAuthTokenTidy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRole(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleName(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameBindSecretId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameBindSecretId(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameBindSecretId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameBoundCidrList - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameBoundCidrList(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameBoundCidrList', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameLocalSecretIds - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameLocalSecretIds(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameLocalSecretIds', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNamePeriod - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNamePeriod(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNamePeriod', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNamePolicies - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNamePolicies(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNamePolicies', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameRoleId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameRoleId(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameRoleId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameSecretId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameSecretId(authRoleName, null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameSecretId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameSecretIdBoundCidrs - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameSecretIdBoundCidrs(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameSecretIdBoundCidrs', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameSecretIdNumUses - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameSecretIdNumUses(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameSecretIdNumUses', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameSecretIdTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameSecretIdTtl(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameSecretIdTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameTokenBoundCidrs - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameTokenBoundCidrs(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameTokenBoundCidrs', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameTokenMaxTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameTokenMaxTtl(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameTokenMaxTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameTokenNumUses - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameTokenNumUses(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameTokenNumUses', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthApproleRoleRoleNameTokenTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthApproleRoleRoleNameTokenTtl(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthApproleRoleRoleNameTokenTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthLdapConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthLdapConfig((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthLdapConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthLdapDuoConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthLdapDuoConfig((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthLdapDuoConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthLdapGroups - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthLdapGroups(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthLdapGroups', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthLdapGroupsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthLdapGroupsName(authName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthLdapGroupsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthLdapMfaConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthLdapMfaConfig((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthLdapMfaConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthLdapUsers - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthLdapUsers(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthLdapUsers', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthLdapUsersName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthLdapUsersName(authName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthLdapUsersName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthRancherConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthRancherConfig((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthRancherConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthRancherRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthRancherRole(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthRancherRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthRancherRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthRancherRoleName(authName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthRancherRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthTokenAccessors - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthTokenAccessors(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthTokenAccessors', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthTokenLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthTokenLookup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthTokenLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthTokenLookupSelf - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthTokenLookupSelf((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthTokenLookupSelf', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthTokenRoles - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthTokenRoles(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthTokenRoles', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAuthTokenRolesRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAuthTokenRolesRoleName(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'getAuthTokenRolesRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityAliasBodyParam = {
canonical_id: 'string',
entity_id: 'string',
id: 'string',
mount_accessor: 'string',
name: 'string'
};
describe('#postIdentityAlias - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityAlias('namespace', identityPostIdentityAliasBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityAlias', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityId = 'fakedata';
const identityupdateIdentityAliasByIdBodyParam = {
canonical_id: 'string',
entity_id: 'string',
mount_accessor: 'string',
name: 'string'
};
describe('#updateIdentityAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityAliasById('namespace', identityId, identityupdateIdentityAliasByIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityEntityBodyParam = {
disabled: true,
id: 'string',
metadata: {},
name: 'string',
policies: [
'string'
]
};
describe('#postIdentityEntity - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityEntity('namespace', identityPostIdentityEntityBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityEntity', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityEntityAliasBodyParam = {
canonical_id: 'string',
entity_id: 'string',
id: 'string',
mount_accessor: 'string',
name: 'string'
};
describe('#postIdentityEntityAlias - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityEntityAlias('namespace', identityPostIdentityEntityAliasBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityEntityAlias', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityEntityAliasByIdBodyParam = {
canonical_id: 'string',
entity_id: 'string',
mount_accessor: 'string',
name: 'string'
};
describe('#updateIdentityEntityAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityEntityAliasById('namespace', identityId, identityupdateIdentityEntityAliasByIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityEntityAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityEntityBatchDeleteBodyParam = {
entity_ids: [
'string'
]
};
describe('#postIdentityEntityBatchDelete - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityEntityBatchDelete('namespace', identityPostIdentityEntityBatchDeleteBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityEntityBatchDelete', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityEntityByIdBodyParam = {
disabled: false,
metadata: {},
name: 'string',
policies: [
'string'
]
};
describe('#updateIdentityEntityById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityEntityById('namespace', identityId, identityupdateIdentityEntityByIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityEntityById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityEntityMergeBodyParam = {
force: false,
from_entity_ids: [
'string'
],
to_entity_id: 'string'
};
describe('#postIdentityEntityMerge - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityEntityMerge('namespace', identityPostIdentityEntityMergeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityEntityMerge', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityName = 'fakedata';
const identityupdateIdentityEntityByNameBodyParam = {
disabled: false,
id: 'string',
metadata: {},
policies: [
'string'
]
};
describe('#updateIdentityEntityByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityEntityByName('namespace', identityName, identityupdateIdentityEntityByNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityEntityByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityGroupBodyParam = {
id: 'string',
member_entity_ids: [
'string'
],
member_group_ids: [
'string'
],
metadata: {},
name: 'string',
policies: [
'string'
],
type: 'string'
};
describe('#postIdentityGroup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityGroup('namespace', identityPostIdentityGroupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityGroup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityGroupAliasBodyParam = {
canonical_id: 'string',
id: 'string',
mount_accessor: 'string',
name: 'string'
};
describe('#postIdentityGroupAlias - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityGroupAlias('namespace', identityPostIdentityGroupAliasBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityGroupAlias', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityGroupAliasByIdBodyParam = {
canonical_id: 'string',
mount_accessor: 'string',
name: 'string'
};
describe('#updateIdentityGroupAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityGroupAliasById('namespace', identityId, identityupdateIdentityGroupAliasByIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityGroupAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityGroupByIdBodyParam = {
member_entity_ids: [
'string'
],
member_group_ids: [
'string'
],
metadata: {},
name: 'string',
policies: [
'string'
],
type: 'string'
};
describe('#updateIdentityGroupById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityGroupById('namespace', identityId, identityupdateIdentityGroupByIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityGroupById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityGroupByNameBodyParam = {
id: 'string',
member_entity_ids: [
'string'
],
member_group_ids: [
'string'
],
metadata: {},
policies: [
'string'
],
type: 'string'
};
describe('#updateIdentityGroupByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityGroupByName('namespace', identityName, identityupdateIdentityGroupByNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityGroupByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityLookupEntityBodyParam = {
alias_id: 'string',
alias_mount_accessor: 'string',
alias_name: 'string',
id: 'string',
name: 'string'
};
describe('#postIdentityLookupEntity - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityLookupEntity('namespace', identityPostIdentityLookupEntityBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityLookupEntity', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityLookupGroupBodyParam = {
alias_id: 'string',
alias_mount_accessor: 'string',
alias_name: 'string',
id: 'string',
name: 'string'
};
describe('#postIdentityLookupGroup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityLookupGroup('namespace', identityPostIdentityLookupGroupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityLookupGroup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityOidcConfigBodyParam = {
issuer: 'string'
};
describe('#postIdentityOidcConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityOidcConfig('namespace', identityPostIdentityOidcConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityOidcConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityOidcIntrospectBodyParam = {
client_id: 'string',
token: 'string'
};
describe('#postIdentityOidcIntrospect - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityOidcIntrospect('namespace', identityPostIdentityOidcIntrospectBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityOidcIntrospect', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityOidcKeyByNameBodyParam = {
algorithm: 'RS256',
allowed_client_ids: [
'string'
],
rotation_period: '24h',
verification_ttl: '24h'
};
describe('#updateIdentityOidcKeyByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityOidcKeyByName('namespace', identityName, identityupdateIdentityOidcKeyByNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityOidcKeyByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identitypostIdentityOidcKeyRotateByNameBodyParam = {
verification_ttl: 3
};
describe('#postIdentityOidcKeyRotateByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityOidcKeyRotateByName('namespace', identityName, identitypostIdentityOidcKeyRotateByNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityOidcKeyRotateByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityOidcRoleByNameBodyParam = {
client_id: 'string',
key: 'string',
template: 'string',
ttl: '24h'
};
describe('#updateIdentityOidcRoleByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityOidcRoleByName('namespace', identityName, identityupdateIdentityOidcRoleByNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityOidcRoleByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityPostIdentityPersonaBodyParam = {
entity_id: 'string',
id: 'string',
metadata: {},
mount_accessor: 'string',
name: 'string'
};
describe('#postIdentityPersona - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postIdentityPersona('namespace', identityPostIdentityPersonaBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'postIdentityPersona', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const identityupdateIdentityPersonaByIdBodyParam = {
entity_id: 'string',
metadata: {},
mount_accessor: 'string',
name: 'string'
};
describe('#updateIdentityPersonaById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateIdentityPersonaById('namespace', identityId, identityupdateIdentityPersonaByIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'updateIdentityPersonaById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityAliases - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityAliases('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityAliases', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityAliasById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityEntityAliases - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityEntityAliases(null, null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityEntityAliases', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityEntityAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityEntityAliasById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityEntityAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityEntities - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityEntities('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityEntities', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityEntityById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityEntityById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityEntityById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityEntityNames - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityEntityNames('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityEntityNames', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityEntityByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityEntityByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityEntityByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityGroupAliasId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityGroupAliasId('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityGroupAliasId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityGroupAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityGroupAliasById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityGroupAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityGroups - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityGroups('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityGroups', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityGroupById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityGroupById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityGroupById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityGroupNames - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityGroupNames('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityGroupNames', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityGroupByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityGroupByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityGroupByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcWellKnownKeys - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcWellKnownKeys('namespace', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcWellKnownKeys', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcWellKnownOpenidConfiguration - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcWellKnownOpenidConfiguration('namespace', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcWellKnownOpenidConfiguration', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcConfig('namespace', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcKeys - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcKeys('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcKeys', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcKeyByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcKeyByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcKeyByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcRoles - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcRoles('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcRoles', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcRoleByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcRoleByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcRoleByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityOidcTokenByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityOidcTokenByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityOidcTokenByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityPersonas - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityPersonas('namespace', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityPersonas', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getIdentityPersonaById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getIdentityPersonaById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'getIdentityPersonaById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPathParam = 'fakedata';
const systemPostSysAuditHashPathBodyParam = {
input: 'string'
};
describe('#postSysAuditHashPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysAuditHashPath(systemPathParam, systemPostSysAuditHashPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysAuditHashPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysAuditPathBodyParam = {
description: 'string',
local: false,
options: {},
type: 'string'
};
describe('#postSysAuditPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysAuditPath(systemPathParam, systemPostSysAuditPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysAuditPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysAuthPathBodyParam = {
config: {},
description: 'string',
external_entropy_access: true,
local: false,
options: {},
plugin_name: 'string',
seal_wrap: true,
type: 'string'
};
describe('#postSysAuthPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysAuthPath(systemPathParam, systemPostSysAuthPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysAuthPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysAuthPathTuneBodyParam = {
allowed_response_headers: [
'string'
],
audit_non_hmac_request_keys: [
'string'
],
audit_non_hmac_response_keys: [
'string'
],
default_lease_ttl: 'string',
description: 'string',
listing_visibility: 'string',
max_lease_ttl: 'string',
options: {},
passthrough_request_headers: [
'string'
],
token_type: 'string'
};
describe('#postSysAuthPathTune - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysAuthPathTune(systemPathParam, systemPostSysAuthPathTuneBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysAuthPathTune', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysCapabilitiesBodyParam = {
path: [
'string'
],
paths: [
'string'
],
token: 'string'
};
describe('#postSysCapabilities - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysCapabilities(systemPostSysCapabilitiesBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysCapabilities', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysCapabilitiesAccessorBodyParam = {
accessor: 'string',
path: [
'string'
],
paths: [
'string'
]
};
describe('#postSysCapabilitiesAccessor - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysCapabilitiesAccessor(systemPostSysCapabilitiesAccessorBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysCapabilitiesAccessor', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysCapabilitiesSelfBodyParam = {
path: [
'string'
],
paths: [
'string'
],
token: 'string'
};
describe('#postSysCapabilitiesSelf - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysCapabilitiesSelf(systemPostSysCapabilitiesSelfBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysCapabilitiesSelf', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemHeader = 'fakedata';
const systemPostSysConfigAuditingRequestHeadersHeaderBodyParam = {
hmac: true
};
describe('#postSysConfigAuditingRequestHeadersHeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysConfigAuditingRequestHeadersHeader(systemHeader, systemPostSysConfigAuditingRequestHeadersHeaderBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysConfigAuditingRequestHeadersHeader', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysConfigControlGroupBodyParam = {
max_ttl: 9
};
describe('#postSysConfigControlGroup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysConfigControlGroup(systemPostSysConfigControlGroupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysConfigControlGroup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysConfigCorsBodyParam = {
allowed_headers: [
'string'
],
allowed_origins: [
'string'
],
enable: false
};
describe('#postSysConfigCors - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysConfigCors(systemPostSysConfigCorsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysConfigCors', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysConfigUiHeadersHeaderBodyParam = {
values: [
'string'
]
};
describe('#postSysConfigUiHeadersHeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysConfigUiHeadersHeader(systemHeader, systemPostSysConfigUiHeadersHeaderBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysConfigUiHeadersHeader', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysControlGroupAuthorizeBodyParam = {
accessor: 'string'
};
describe('#postSysControlGroupAuthorize - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysControlGroupAuthorize(systemPostSysControlGroupAuthorizeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysControlGroupAuthorize', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysControlGroupRequestBodyParam = {
accessor: 'string'
};
describe('#postSysControlGroupRequest - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysControlGroupRequest(systemPostSysControlGroupRequestBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysControlGroupRequest', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysGenerateRootBodyParam = {
pgp_key: 'string'
};
describe('#postSysGenerateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysGenerateRoot(systemPostSysGenerateRootBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysGenerateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysGenerateRootAttemptBodyParam = {
pgp_key: 'string'
};
describe('#postSysGenerateRootAttempt - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysGenerateRootAttempt(systemPostSysGenerateRootAttemptBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysGenerateRootAttempt', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysGenerateRootUpdateBodyParam = {
key: 'string',
nonce: 'string'
};
describe('#postSysGenerateRootUpdate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysGenerateRootUpdate(systemPostSysGenerateRootUpdateBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysGenerateRootUpdate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysInitBodyParam = {
pgp_keys: [
'string'
],
recovery_pgp_keys: [
'string'
],
recovery_shares: 1,
recovery_threshold: 2,
root_token_pgp_key: 'string',
secret_shares: 4,
secret_threshold: 6,
stored_shares: 4
};
describe('#postSysInit - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysInit(systemPostSysInitBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysInit', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysLeasesLookupBodyParam = {
lease_id: 'string'
};
describe('#postSysLeasesLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesLookup(systemPostSysLeasesLookupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysLeasesRenewBodyParam = {
increment: 8,
lease_id: 'string',
url_lease_id: 'string'
};
describe('#postSysLeasesRenew - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesRenew(systemPostSysLeasesRenewBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesRenew', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemUrlLeaseId = 'fakedata';
const systemPostSysLeasesRenewUrlLeaseIdBodyParam = {
increment: 8,
lease_id: 'string'
};
describe('#postSysLeasesRenewUrlLeaseId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesRenewUrlLeaseId(systemUrlLeaseId, systemPostSysLeasesRenewUrlLeaseIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesRenewUrlLeaseId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysLeasesRevokeBodyParam = {
lease_id: 'string',
sync: true,
url_lease_id: 'string'
};
describe('#postSysLeasesRevoke - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesRevoke(systemPostSysLeasesRevokeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesRevoke', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPrefix = 'fakedata';
describe('#postSysLeasesRevokeForcePrefix - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesRevokeForcePrefix(systemPrefix, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesRevokeForcePrefix', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysLeasesRevokePrefixPrefixBodyParam = {
sync: true
};
describe('#postSysLeasesRevokePrefixPrefix - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesRevokePrefixPrefix(systemPrefix, systemPostSysLeasesRevokePrefixPrefixBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesRevokePrefixPrefix', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysLeasesRevokeUrlLeaseIdBodyParam = {
lease_id: 'string',
sync: true
};
describe('#postSysLeasesRevokeUrlLeaseId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesRevokeUrlLeaseId(systemUrlLeaseId, systemPostSysLeasesRevokeUrlLeaseIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesRevokeUrlLeaseId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysLeasesTidy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLeasesTidy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLeasesTidy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysLicenseBodyParam = {
text: 'string'
};
describe('#postSysLicense - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysLicense(systemPostSysLicenseBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysLicense', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemName = 'fakedata';
const systemPostSysMfaMethodDuoNameBodyParam = {
api_hostname: 'string',
integration_key: 'string',
mount_accessor: 'string',
push_info: 'string',
secret_key: 'string',
username_format: 'string'
};
describe('#postSysMfaMethodDuoName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMfaMethodDuoName(systemName, systemPostSysMfaMethodDuoNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMfaMethodDuoName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysMfaMethodOktaNameBodyParam = {
api_token: 'string',
base_url: 'string',
mount_accessor: 'string',
org_name: 'string',
primary_email: true,
production: false,
username_format: 'string'
};
describe('#postSysMfaMethodOktaName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMfaMethodOktaName(systemName, systemPostSysMfaMethodOktaNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMfaMethodOktaName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysMfaMethodPingidNameBodyParam = {
mount_accessor: 'string',
settings_file_base64: 'string',
username_format: 'string'
};
describe('#postSysMfaMethodPingidName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMfaMethodPingidName(systemName, systemPostSysMfaMethodPingidNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMfaMethodPingidName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysMfaMethodTotpNameBodyParam = {
algorithm: 'SHA1',
digits: 6,
issuer: 'string',
key_size: 20,
period: 30,
qr_size: 200,
skew: 1
};
describe('#postSysMfaMethodTotpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMfaMethodTotpName(systemName, systemPostSysMfaMethodTotpNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMfaMethodTotpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysMfaMethodTotpNameAdminDestroyBodyParam = {
entity_id: 'string'
};
describe('#postSysMfaMethodTotpNameAdminDestroy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMfaMethodTotpNameAdminDestroy(systemName, systemPostSysMfaMethodTotpNameAdminDestroyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMfaMethodTotpNameAdminDestroy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysMfaMethodTotpNameAdminGenerateBodyParam = {
entity_id: 'string'
};
describe('#postSysMfaMethodTotpNameAdminGenerate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMfaMethodTotpNameAdminGenerate(systemName, systemPostSysMfaMethodTotpNameAdminGenerateBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMfaMethodTotpNameAdminGenerate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysMountsPathBodyParam = {
config: {},
description: 'string',
external_entropy_access: false,
local: false,
options: {},
plugin_name: 'string',
seal_wrap: true,
type: 'string'
};
describe('#postSysMountsPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMountsPath(systemPathParam, systemPostSysMountsPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMountsPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysMountsPathTuneBodyParam = {
allowed_response_headers: [
'string'
],
audit_non_hmac_request_keys: [
'string'
],
audit_non_hmac_response_keys: [
'string'
],
default_lease_ttl: 'string',
description: 'string',
listing_visibility: 'string',
max_lease_ttl: 'string',
options: {},
passthrough_request_headers: [
'string'
],
token_type: 'string'
};
describe('#postSysMountsPathTune - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysMountsPathTune(systemPathParam, systemPostSysMountsPathTuneBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysMountsPathTune', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysNamespacesPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysNamespacesPath(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysNamespacesPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysPluginsCatalogNameBodyParam = {
args: [
'string'
],
command: 'string',
env: [
'string'
],
sha256: 'string',
sha_256: 'string',
type: 'string'
};
describe('#postSysPluginsCatalogName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPluginsCatalogName(systemName, systemPostSysPluginsCatalogNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPluginsCatalogName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemType = 'fakedata';
const systemPostSysPluginsCatalogTypeNameBodyParam = {
args: [
'string'
],
command: 'string',
env: [
'string'
],
sha256: 'string',
sha_256: 'string'
};
describe('#postSysPluginsCatalogTypeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPluginsCatalogTypeName(systemName, systemType, systemPostSysPluginsCatalogTypeNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPluginsCatalogTypeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysPluginsReloadBackendBodyParam = {
mounts: [
'string'
],
plugin: 'string',
scope: 'string'
};
describe('#postSysPluginsReloadBackend - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPluginsReloadBackend(systemPostSysPluginsReloadBackendBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPluginsReloadBackend', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysPoliciesAclNameBodyParam = {
policy: 'string'
};
describe('#postSysPoliciesAclName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPoliciesAclName(systemName, systemPostSysPoliciesAclNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPoliciesAclName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysPoliciesEgpNameBodyParam = {
enforcement_level: 'string',
paths: [
'string'
],
policy: 'string'
};
describe('#postSysPoliciesEgpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPoliciesEgpName(systemName, systemPostSysPoliciesEgpNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPoliciesEgpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysPoliciesPasswordNameBodyParam = {
policy: 'string'
};
describe('#postSysPoliciesPasswordName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPoliciesPasswordName(systemName, systemPostSysPoliciesPasswordNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPoliciesPasswordName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysPoliciesRgpNameBodyParam = {
enforcement_level: 'string',
policy: 'string'
};
describe('#postSysPoliciesRgpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPoliciesRgpName(systemName, systemPostSysPoliciesRgpNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPoliciesRgpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysPolicyNameBodyParam = {
policy: 'string',
rules: 'string'
};
describe('#postSysPolicyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysPolicyName(systemName, systemPostSysPolicyNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysPolicyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysQuotasConfigBodyParam = {
enable_rate_limit_audit_logging: true
};
describe('#postSysQuotasConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysQuotasConfig(systemPostSysQuotasConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysQuotasConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysQuotasLeaseCountNameBodyParam = {
max_leases: 6,
path: 'string',
type: 'string'
};
describe('#postSysQuotasLeaseCountName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysQuotasLeaseCountName(systemName, systemPostSysQuotasLeaseCountNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysQuotasLeaseCountName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysQuotasRateLimitNameBodyParam = {
path: 'string',
rate: null,
type: 'string'
};
describe('#postSysQuotasRateLimitName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysQuotasRateLimitName(systemName, systemPostSysQuotasRateLimitNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysQuotasRateLimitName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRekeyInitBodyParam = {
backup: false,
pgp_keys: [
'string'
],
require_verification: true,
secret_shares: 10,
secret_threshold: 5
};
describe('#postSysRekeyInit - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRekeyInit(systemPostSysRekeyInitBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRekeyInit', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRekeyUpdateBodyParam = {
key: 'string',
nonce: 'string'
};
describe('#postSysRekeyUpdate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRekeyUpdate(systemPostSysRekeyUpdateBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRekeyUpdate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRekeyVerifyBodyParam = {
key: 'string',
nonce: 'string'
};
describe('#postSysRekeyVerify - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRekeyVerify(systemPostSysRekeyVerifyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRekeyVerify', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRemountBodyParam = {
from: 'string',
to: 'string'
};
describe('#postSysRemount - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRemount(systemPostSysRemountBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRemount', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRenewBodyParam = {
increment: 2,
lease_id: 'string',
url_lease_id: 'string'
};
describe('#postSysRenew - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRenew(systemPostSysRenewBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRenew', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRenewUrlLeaseIdBodyParam = {
increment: 6,
lease_id: 'string'
};
describe('#postSysRenewUrlLeaseId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRenewUrlLeaseId(systemUrlLeaseId, systemPostSysRenewUrlLeaseIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRenewUrlLeaseId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationDrPrimaryDemote - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrPrimaryDemote((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrPrimaryDemote', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationDrPrimaryDisable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrPrimaryDisable((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrPrimaryDisable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrPrimaryEnableBodyParam = {
primary_cluster_addr: 'string'
};
describe('#postSysReplicationDrPrimaryEnable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrPrimaryEnable(systemPostSysReplicationDrPrimaryEnableBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrPrimaryEnable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrPrimaryRevokeSecondaryBodyParam = {
id: 'string'
};
describe('#postSysReplicationDrPrimaryRevokeSecondary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrPrimaryRevokeSecondary(systemPostSysReplicationDrPrimaryRevokeSecondaryBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrPrimaryRevokeSecondary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrPrimarySecondaryTokenBodyParam = {
id: 'string',
secondary_public_key: 'string',
ttl: '30m'
};
describe('#postSysReplicationDrPrimarySecondaryToken - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrPrimarySecondaryToken(systemPostSysReplicationDrPrimarySecondaryTokenBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrPrimarySecondaryToken', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryDisableBodyParam = {
dr_operation_token: 'string'
};
describe('#postSysReplicationDrSecondaryDisable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryDisable(systemPostSysReplicationDrSecondaryDisableBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryDisable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryEnableBodyParam = {
ca_file: 'string',
ca_path: 'string',
client_cert_pem: 'string',
client_key_pem: 'string',
primary_api_addr: 'string',
token: 'string'
};
describe('#postSysReplicationDrSecondaryEnable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryEnable(systemPostSysReplicationDrSecondaryEnableBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryEnable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationDrSecondaryGeneratePublicKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryGeneratePublicKey((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryGeneratePublicKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryLicenseBodyParam = {
dr_operation_token: 'string',
text: 'string'
};
describe('#postSysReplicationDrSecondaryLicense - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryLicense(systemPostSysReplicationDrSecondaryLicenseBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryLicense', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryOperationTokenDeleteBodyParam = {
dr_operation_token: 'string'
};
describe('#postSysReplicationDrSecondaryOperationTokenDelete - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryOperationTokenDelete(systemPostSysReplicationDrSecondaryOperationTokenDeleteBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryOperationTokenDelete', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryPromoteBodyParam = {
dr_operation_token: 'string',
force: false,
primary_cluster_addr: 'string'
};
describe('#postSysReplicationDrSecondaryPromote - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryPromote(systemPostSysReplicationDrSecondaryPromoteBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryPromote', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryRecoverBodyParam = {
dr_operation_token: 'string'
};
describe('#postSysReplicationDrSecondaryRecover - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryRecover(systemPostSysReplicationDrSecondaryRecoverBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryRecover', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryReindexBodyParam = {
diff: false,
dr_operation_token: 'string',
force: false,
skip_flush: false
};
describe('#postSysReplicationDrSecondaryReindex - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryReindex(systemPostSysReplicationDrSecondaryReindexBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryReindex', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationDrSecondaryUpdatePrimaryBodyParam = {
ca_file: 'string',
ca_path: 'string',
client_cert_pem: 'string',
client_key_pem: 'string',
dr_operation_token: 'string',
primary_api_addr: 'string',
token: 'string'
};
describe('#postSysReplicationDrSecondaryUpdatePrimary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationDrSecondaryUpdatePrimary(systemPostSysReplicationDrSecondaryUpdatePrimaryBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationDrSecondaryUpdatePrimary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationPerformancePrimaryDemote - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformancePrimaryDemote((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformancePrimaryDemote', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationPerformancePrimaryDisable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformancePrimaryDisable((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformancePrimaryDisable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPerformancePrimaryEnableBodyParam = {
primary_cluster_addr: 'string'
};
describe('#postSysReplicationPerformancePrimaryEnable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformancePrimaryEnable(systemPostSysReplicationPerformancePrimaryEnableBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformancePrimaryEnable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemId = 'fakedata';
const systemPostSysReplicationPerformancePrimaryMountFilterIdBodyParam = {
mode: 'allow',
paths: [
'string'
]
};
describe('#postSysReplicationPerformancePrimaryMountFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformancePrimaryMountFilterId(systemId, systemPostSysReplicationPerformancePrimaryMountFilterIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformancePrimaryMountFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPerformancePrimaryPathsFilterIdBodyParam = {
mode: 'allow',
paths: [
'string'
]
};
describe('#postSysReplicationPerformancePrimaryPathsFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformancePrimaryPathsFilterId(systemId, systemPostSysReplicationPerformancePrimaryPathsFilterIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformancePrimaryPathsFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPerformancePrimaryRevokeSecondaryBodyParam = {
id: 'string'
};
describe('#postSysReplicationPerformancePrimaryRevokeSecondary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformancePrimaryRevokeSecondary(systemPostSysReplicationPerformancePrimaryRevokeSecondaryBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformancePrimaryRevokeSecondary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPerformancePrimarySecondaryTokenBodyParam = {
id: 'string',
secondary_public_key: 'string',
ttl: '30m'
};
describe('#postSysReplicationPerformancePrimarySecondaryToken - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformancePrimarySecondaryToken(systemPostSysReplicationPerformancePrimarySecondaryTokenBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformancePrimarySecondaryToken', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationPerformanceSecondaryDisable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformanceSecondaryDisable((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformanceSecondaryDisable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPerformanceSecondaryEnableBodyParam = {
ca_file: 'string',
ca_path: 'string',
client_cert_pem: 'string',
client_key_pem: 'string',
primary_api_addr: 'string',
token: 'string'
};
describe('#postSysReplicationPerformanceSecondaryEnable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformanceSecondaryEnable(systemPostSysReplicationPerformanceSecondaryEnableBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformanceSecondaryEnable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationPerformanceSecondaryGeneratePublicKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformanceSecondaryGeneratePublicKey((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformanceSecondaryGeneratePublicKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPerformanceSecondaryPromoteBodyParam = {
force: false,
primary_cluster_addr: 'string'
};
describe('#postSysReplicationPerformanceSecondaryPromote - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformanceSecondaryPromote(systemPostSysReplicationPerformanceSecondaryPromoteBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformanceSecondaryPromote', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPerformanceSecondaryUpdatePrimaryBodyParam = {
ca_file: 'string',
ca_path: 'string',
client_cert_pem: 'string',
client_key_pem: 'string',
primary_api_addr: 'string',
token: 'string'
};
describe('#postSysReplicationPerformanceSecondaryUpdatePrimary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPerformanceSecondaryUpdatePrimary(systemPostSysReplicationPerformanceSecondaryUpdatePrimaryBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPerformanceSecondaryUpdatePrimary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationPrimaryDemote - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPrimaryDemote((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPrimaryDemote', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationPrimaryDisable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPrimaryDisable((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPrimaryDisable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPrimaryEnableBodyParam = {
primary_cluster_addr: 'string'
};
describe('#postSysReplicationPrimaryEnable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPrimaryEnable(systemPostSysReplicationPrimaryEnableBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPrimaryEnable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPrimaryRevokeSecondaryBodyParam = {
id: 'string'
};
describe('#postSysReplicationPrimaryRevokeSecondary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPrimaryRevokeSecondary(systemPostSysReplicationPrimaryRevokeSecondaryBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPrimaryRevokeSecondary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationPrimarySecondaryTokenBodyParam = {
id: 'string',
secondary_public_key: 'string',
ttl: '30m'
};
describe('#postSysReplicationPrimarySecondaryToken - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationPrimarySecondaryToken(systemPostSysReplicationPrimarySecondaryTokenBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationPrimarySecondaryToken', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationRecover - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationRecover((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationRecover', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationReindexBodyParam = {
diff: true,
force: true,
skip_flush: false
};
describe('#postSysReplicationReindex - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationReindex(systemPostSysReplicationReindexBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationReindex', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysReplicationSecondaryDisable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationSecondaryDisable((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationSecondaryDisable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationSecondaryEnableBodyParam = {
ca_file: 'string',
ca_path: 'string',
client_cert_pem: 'string',
client_key_pem: 'string',
primary_api_addr: 'string',
token: 'string'
};
describe('#postSysReplicationSecondaryEnable - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationSecondaryEnable(systemPostSysReplicationSecondaryEnableBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationSecondaryEnable', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationSecondaryPromoteBodyParam = {
force: true,
primary_cluster_addr: 'string'
};
describe('#postSysReplicationSecondaryPromote - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationSecondaryPromote(systemPostSysReplicationSecondaryPromoteBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationSecondaryPromote', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysReplicationSecondaryUpdatePrimaryBodyParam = {
ca_file: 'string',
ca_path: 'string',
client_cert_pem: 'string',
client_key_pem: 'string',
primary_api_addr: 'string',
token: 'string'
};
describe('#postSysReplicationSecondaryUpdatePrimary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysReplicationSecondaryUpdatePrimary(systemPostSysReplicationSecondaryUpdatePrimaryBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysReplicationSecondaryUpdatePrimary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRevokeBodyParam = {
lease_id: 'string',
sync: true,
url_lease_id: 'string'
};
describe('#postSysRevoke - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRevoke(systemPostSysRevokeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRevoke', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysRevokeForcePrefix - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRevokeForcePrefix(systemPrefix, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRevokeForcePrefix', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRevokePrefixPrefixBodyParam = {
sync: true
};
describe('#postSysRevokePrefixPrefix - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRevokePrefixPrefix(systemPrefix, systemPostSysRevokePrefixPrefixBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRevokePrefixPrefix', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRevokeUrlLeaseIdBodyParam = {
lease_id: 'string',
sync: true
};
describe('#postSysRevokeUrlLeaseId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRevokeUrlLeaseId(systemUrlLeaseId, systemPostSysRevokeUrlLeaseIdBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRevokeUrlLeaseId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRotate((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysSeal - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysSeal((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysSeal', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysSealwrapRewrap - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysSealwrapRewrap((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysSealwrapRewrap', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysStepDown - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStepDown((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStepDown', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysStorageRaftBootstrapAnswerBodyParam = {
answer: 'string',
cluster_addr: 'string',
non_voter: true,
server_id: 'string'
};
describe('#postSysStorageRaftBootstrapAnswer - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStorageRaftBootstrapAnswer(systemPostSysStorageRaftBootstrapAnswerBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStorageRaftBootstrapAnswer', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysStorageRaftBootstrapChallengeBodyParam = {
server_id: 'string'
};
describe('#postSysStorageRaftBootstrapChallenge - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStorageRaftBootstrapChallenge(systemPostSysStorageRaftBootstrapChallengeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStorageRaftBootstrapChallenge', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysStorageRaftRemovePeerBodyParam = {
server_id: 'string'
};
describe('#postSysStorageRaftRemovePeer - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStorageRaftRemovePeer(systemPostSysStorageRaftRemovePeerBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStorageRaftRemovePeer', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysStorageRaftSnapshot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStorageRaftSnapshot((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStorageRaftSnapshot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysStorageRaftSnapshotForce - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStorageRaftSnapshotForce((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStorageRaftSnapshotForce', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysToolsHashBodyParam = {
algorithm: 'sha2-256',
format: 'hex',
input: 'string',
urlalgorithm: 'string'
};
describe('#postSysToolsHash - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysToolsHash(systemPostSysToolsHashBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysToolsHash', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemUrlalgorithm = 'fakedata';
const systemPostSysToolsHashUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
format: 'hex',
input: 'string'
};
describe('#postSysToolsHashUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysToolsHashUrlalgorithm(systemUrlalgorithm, systemPostSysToolsHashUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysToolsHashUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysToolsRandomBodyParam = {
bytes: 32,
format: 'base64',
urlbytes: 'string'
};
describe('#postSysToolsRandom - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysToolsRandom(systemPostSysToolsRandomBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysToolsRandom', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemUrlbytes = 'fakedata';
const systemPostSysToolsRandomUrlbytesBodyParam = {
bytes: 32,
format: 'base64'
};
describe('#postSysToolsRandomUrlbytes - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysToolsRandomUrlbytes(systemUrlbytes, systemPostSysToolsRandomUrlbytesBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysToolsRandomUrlbytes', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysUnsealBodyParam = {
key: 'string',
reset: false
};
describe('#postSysUnseal - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysUnseal(systemPostSysUnsealBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysUnseal', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysWrappingLookupBodyParam = {
token: 'string'
};
describe('#postSysWrappingLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysWrappingLookup(systemPostSysWrappingLookupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysWrappingLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysWrappingRewrapBodyParam = {
token: 'string'
};
describe('#postSysWrappingRewrap - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysWrappingRewrap(systemPostSysWrappingRewrapBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysWrappingRewrap', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysWrappingUnwrapBodyParam = {
token: 'string'
};
describe('#postSysWrappingUnwrap - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysWrappingUnwrap(systemPostSysWrappingUnwrapBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysWrappingUnwrap', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSysWrappingWrap - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysWrappingWrap((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysWrappingWrap', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysAudit - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysAudit((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysAudit', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysAuth - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysAuth((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysAuth', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysAuthPathTune - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysAuthPathTune(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysAuthPathTune', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysConfigAuditingRequestHeaders - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysConfigAuditingRequestHeaders((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysConfigAuditingRequestHeaders', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysConfigAuditingRequestHeadersHeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysConfigAuditingRequestHeadersHeader(systemHeader, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysConfigAuditingRequestHeadersHeader', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysConfigControlGroup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysConfigControlGroup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysConfigControlGroup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysConfigCors - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysConfigCors((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysConfigCors', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysConfigStateSanitized - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysConfigStateSanitized((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysConfigStateSanitized', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysConfigUiHeaders - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysConfigUiHeaders(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysConfigUiHeaders', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysConfigUiHeadersHeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysConfigUiHeadersHeader(systemHeader, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysConfigUiHeadersHeader', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysGenerateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysGenerateRoot((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysGenerateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysGenerateRootAttempt - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysGenerateRootAttempt((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysGenerateRootAttempt', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysHealth - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysHealth((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysHealth', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysHostInfo - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysHostInfo((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysHostInfo', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInit - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInit((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInit', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInternalSpecsOpenapi - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInternalSpecsOpenapi((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInternalSpecsOpenapi', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInternalUiMounts - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInternalUiMounts((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInternalUiMounts', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInternalUiMountsPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInternalUiMountsPath(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInternalUiMountsPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysKeyStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysKeyStatus((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysKeyStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysLeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysLeader((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysLeader', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysLeasesLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysLeasesLookup(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysLeasesLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysLeasesLookupPrefix - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysLeasesLookupPrefix(systemPrefix, null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysLeasesLookupPrefix', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysLicense - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysLicense((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysLicense', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMetrics - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMetrics(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMetrics', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMfaMethod - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMfaMethod(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMfaMethod', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMfaMethodDuoName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMfaMethodDuoName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMfaMethodDuoName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMfaMethodOktaName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMfaMethodOktaName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMfaMethodOktaName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMfaMethodPingidName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMfaMethodPingidName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMfaMethodPingidName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMfaMethodTotpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMfaMethodTotpName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMfaMethodTotpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMfaMethodTotpNameGenerate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMfaMethodTotpNameGenerate(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMfaMethodTotpNameGenerate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMonitor - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMonitor(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMonitor', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMounts - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMounts((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMounts', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysMountsPathTune - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysMountsPathTune(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysMountsPathTune', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysNamespaces - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysNamespaces(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysNamespaces', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysNamespacesPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysNamespacesPath(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysNamespacesPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPluginsCatalog - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPluginsCatalog((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPluginsCatalog', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPluginsCatalogName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPluginsCatalogName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPluginsCatalogName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPluginsCatalogType - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPluginsCatalogType(systemType, null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPluginsCatalogType', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPluginsCatalogTypeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPluginsCatalogTypeName(systemName, systemType, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPluginsCatalogTypeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPluginsReloadBackendStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPluginsReloadBackendStatus((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPluginsReloadBackendStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesAcl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesAcl(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesAcl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesAclName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesAclName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesAclName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesEgp - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesEgp(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesEgp', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesEgpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesEgpName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesEgpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesPasswordName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesPasswordName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesPasswordName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesPasswordNameGenerate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesPasswordNameGenerate(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesPasswordNameGenerate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesRgp - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesRgp(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesRgp', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPoliciesRgpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPoliciesRgpName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPoliciesRgpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPolicy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPolicy(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPolicy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPolicyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPolicyName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPolicyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprof - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprof((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprof', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofCmdline - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofCmdline((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofCmdline', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofGoroutine - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofGoroutine((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofGoroutine', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofHeap - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofHeap((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofHeap', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofProfile - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofProfile((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofProfile', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofSymbol - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofSymbol((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofSymbol', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofTrace - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofTrace((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofTrace', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysQuotasConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysQuotasConfig((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysQuotasConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysQuotasLeaseCount - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysQuotasLeaseCount(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysQuotasLeaseCount', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysQuotasLeaseCountName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysQuotasLeaseCountName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysQuotasLeaseCountName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysQuotasRateLimit - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysQuotasRateLimit(null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysQuotasRateLimit', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysQuotasRateLimitName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysQuotasRateLimitName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysQuotasRateLimitName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysRekeyBackup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysRekeyBackup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysRekeyBackup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysRekeyInit - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysRekeyInit((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysRekeyInit', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysRekeyRecoveryKeyBackup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysRekeyRecoveryKeyBackup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysRekeyRecoveryKeyBackup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysRekeyVerify - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysRekeyVerify((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysRekeyVerify', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationDrSecondaryLicense - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationDrSecondaryLicense((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationDrSecondaryLicense', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationDrStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationDrStatus((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationDrStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationPerformancePrimaryDynamicFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationPerformancePrimaryDynamicFilterId(systemId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationPerformancePrimaryDynamicFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationPerformancePrimaryMountFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationPerformancePrimaryMountFilterId(systemId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationPerformancePrimaryMountFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationPerformancePrimaryPathsFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationPerformancePrimaryPathsFilterId(systemId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationPerformancePrimaryPathsFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationPerformanceSecondaryDynamicFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationPerformanceSecondaryDynamicFilterId(systemId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationPerformanceSecondaryDynamicFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationPerformanceStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationPerformanceStatus((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationPerformanceStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysReplicationStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysReplicationStatus((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysReplicationStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysSealStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysSealStatus((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysSealStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysSealwrapRewrap - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysSealwrapRewrap((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysSealwrapRewrap', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysStorageRaftConfiguration - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysStorageRaftConfiguration((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysStorageRaftConfiguration', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysStorageRaftSnapshot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysStorageRaftSnapshot((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysStorageRaftSnapshot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysWrappingLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysWrappingLookup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysWrappingLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteKvSecretDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteKvSecretDataPath('namespace', 'mount', secretsPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteKvSecretDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteKvSecretMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteKvSecretMetadataPath('namespace', 'mount', secretsPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteKvSecretMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteCubbyholeSecretPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteCubbyholeSecretPath('namespace', 'mount', secretsPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteCubbyholeSecretPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deletePkiSecretRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deletePkiSecretRolesName('namespace', 'mount', secretsName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deletePkiSecretRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deletePkiSecretRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deletePkiSecretRoot('namespace', 'mount', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deletePkiSecretRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleName(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameBindSecretId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameBindSecretId(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameBindSecretId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameBoundCidrList - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameBoundCidrList(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameBoundCidrList', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNamePeriod - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNamePeriod(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNamePeriod', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNamePolicies - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNamePolicies(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNamePolicies', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameSecretIdAccessorDestroy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameSecretIdAccessorDestroy(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameSecretIdAccessorDestroy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameSecretIdBoundCidrs - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameSecretIdBoundCidrs(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameSecretIdBoundCidrs', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameSecretIdNumUses - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameSecretIdNumUses(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameSecretIdNumUses', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameSecretIdTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameSecretIdTtl(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameSecretIdTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameSecretIdDestroy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameSecretIdDestroy(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameSecretIdDestroy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameTokenBoundCidrs - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameTokenBoundCidrs(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameTokenBoundCidrs', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameTokenMaxTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameTokenMaxTtl(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameTokenMaxTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameTokenNumUses - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameTokenNumUses(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameTokenNumUses', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthApproleRoleRoleNameTokenTtl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthApproleRoleRoleNameTokenTtl(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthApproleRoleRoleNameTokenTtl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthLdapGroupsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthLdapGroupsName(authName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthLdapGroupsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthLdapUsersName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthLdapUsersName(authName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthLdapUsersName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthRancherRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthRancherRoleName(authName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthRancherRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAuthTokenRolesRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAuthTokenRolesRoleName(authRoleName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Auth', 'deleteAuthTokenRolesRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityAliasById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityEntityAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityEntityAliasById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityEntityAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityEntityById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityEntityById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityEntityById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityEntityByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityEntityByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityEntityByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityGroupAliasById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityGroupAliasById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityGroupAliasById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityGroupById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityGroupById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityGroupById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityGroupByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityGroupByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityGroupByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityOidcKeyByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityOidcKeyByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityOidcKeyByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityOidcRoleByName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityOidcRoleByName('namespace', identityName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityOidcRoleByName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteIdentityPersonaById - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteIdentityPersonaById('namespace', identityId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Identity', 'deleteIdentityPersonaById', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysAuditPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysAuditPath(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysAuditPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysAuthPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysAuthPath(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysAuthPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysConfigAuditingRequestHeadersHeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysConfigAuditingRequestHeadersHeader(systemHeader, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysConfigAuditingRequestHeadersHeader', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysConfigControlGroup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysConfigControlGroup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysConfigControlGroup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysConfigCors - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysConfigCors((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysConfigCors', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysConfigUiHeadersHeader - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysConfigUiHeadersHeader(systemHeader, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysConfigUiHeadersHeader', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysGenerateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysGenerateRoot((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysGenerateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysGenerateRootAttempt - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysGenerateRootAttempt((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysGenerateRootAttempt', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysMfaMethodDuoName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysMfaMethodDuoName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysMfaMethodDuoName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysMfaMethodOktaName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysMfaMethodOktaName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysMfaMethodOktaName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysMfaMethodPingidName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysMfaMethodPingidName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysMfaMethodPingidName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysMfaMethodTotpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysMfaMethodTotpName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysMfaMethodTotpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysMountsPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysMountsPath(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysMountsPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysNamespacesPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysNamespacesPath(systemPathParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysNamespacesPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysPluginsCatalogName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysPluginsCatalogName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysPluginsCatalogName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysPluginsCatalogTypeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysPluginsCatalogTypeName(systemName, systemType, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysPluginsCatalogTypeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysPoliciesAclName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysPoliciesAclName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysPoliciesAclName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysPoliciesEgpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysPoliciesEgpName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysPoliciesEgpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysPoliciesPasswordName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysPoliciesPasswordName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysPoliciesPasswordName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysPoliciesRgpName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysPoliciesRgpName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysPoliciesRgpName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysPolicyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysPolicyName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysPolicyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysQuotasLeaseCountName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysQuotasLeaseCountName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysQuotasLeaseCountName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysQuotasRateLimitName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysQuotasRateLimitName(systemName, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysQuotasRateLimitName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysRekeyBackup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysRekeyBackup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysRekeyBackup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysRekeyInit - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysRekeyInit((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysRekeyInit', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysRekeyRecoveryKeyBackup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysRekeyRecoveryKeyBackup((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysRekeyRecoveryKeyBackup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysRekeyVerify - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysRekeyVerify((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysRekeyVerify', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysReplicationPerformancePrimaryMountFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysReplicationPerformancePrimaryMountFilterId(systemId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysReplicationPerformancePrimaryMountFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysReplicationPerformancePrimaryPathsFilterId - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysReplicationPerformancePrimaryPathsFilterId(systemId, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysReplicationPerformancePrimaryPathsFilterId', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAdConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAdConfig('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAdConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsCreateAdConfigBodyParam = {
anonymous_group_search: true,
binddn: 'string',
bindpass: 'string',
case_sensitive_names: false,
certificate: 'string',
client_tls_cert: 'string',
client_tls_key: 'string',
deny_null_bind: true,
discoverdn: false,
formatter: 'string',
groupattr: 'cn',
groupdn: 'string',
groupfilter: '(|(memberUid={{.Username}})(member={{.UserDN}})(uniqueMember={{.UserDN}}))',
insecure_tls: false,
last_rotation_tolerance: 5,
length: 64,
max_ttl: 1,
password_policy: 'string',
request_timeout: 10,
starttls: false,
tls_max_version: 'tls13',
tls_min_version: 'tls11',
ttl: 3,
upndomain: 'string',
url: 'ldap://127.0.0.1',
use_pre111_group_cn_behavior: false,
use_token_groups: false,
userattr: 'cn',
userdn: 'string'
};
describe('#createAdConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.createAdConfig('fakedata', 'fakedata', secretsCreateAdConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'createAdConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAdConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAdConfig('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteAdConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAdCredsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAdCredsName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAdCredsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAdLibrary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAdLibrary('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAdLibrary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsCreateAdLibraryManageNameCheckInBodyParam = {
service_account_names: [
'string'
]
};
describe('#createAdLibraryManageNameCheckIn - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.createAdLibraryManageNameCheckIn('fakedata', 'fakedata', 'fakedata', secretsCreateAdLibraryManageNameCheckInBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'createAdLibraryManageNameCheckIn', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAdLibraryName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAdLibraryName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAdLibraryName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsUpdateAdLibraryNameBodyParam = {
disable_check_in_enforcement: false,
max_ttl: 86400,
service_account_names: [
'string'
],
ttl: 86400
};
describe('#updateAdLibraryName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateAdLibraryName('fakedata', 'fakedata', 'fakedata', secretsUpdateAdLibraryNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'updateAdLibraryName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAdLibraryName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAdLibraryName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteAdLibraryName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsCreateAdLibraryNameCheckInBodyParam = {
service_account_names: [
'string'
]
};
describe('#createAdLibraryNameCheckIn - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.createAdLibraryNameCheckIn('fakedata', 'fakedata', 'fakedata', secretsCreateAdLibraryNameCheckInBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'createAdLibraryNameCheckIn', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsCreateAdLibraryNameCheckOutBodyParam = {
ttl: 8
};
describe('#createAdLibraryNameCheckOut - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.createAdLibraryNameCheckOut('fakedata', 'fakedata', 'fakedata', secretsCreateAdLibraryNameCheckOutBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'createAdLibraryNameCheckOut', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAdLibraryNameStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAdLibraryNameStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAdLibraryNameStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAdRotateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAdRotateRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAdRotateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#createAdRotateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.createAdRotateRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'createAdRotateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAlicloudRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAlicloudRole('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAlicloudRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAlicloudRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAlicloudRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAlicloudRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostAlicloudRoleNameBodyParam = {
inline_policies: 'string',
max_ttl: 3,
remote_policies: [
'string'
],
role_arn: 'string',
ttl: 10
};
describe('#postAlicloudRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAlicloudRoleName('fakedata', 'fakedata', 'fakedata', secretsPostAlicloudRoleNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postAlicloudRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteAlicloudRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteAlicloudRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteAlicloudRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAwsConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAwsConfigLease('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAwsConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostAwsConfigLeaseBodyParam = {
lease: 'string',
lease_max: 'string'
};
describe('#postAwsConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAwsConfigLease('fakedata', 'fakedata', secretsPostAwsConfigLeaseBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postAwsConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAwsConfigRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAwsConfigRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAwsConfigRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostAwsConfigRootBodyParam = {
access_key: 'string',
iam_endpoint: 'string',
max_retries: -1,
region: 'string',
secret_key: 'string',
sts_endpoint: 'string'
};
describe('#postAwsConfigRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAwsConfigRoot('fakedata', 'fakedata', secretsPostAwsConfigRootBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postAwsConfigRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postAwsConfigRotateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAwsConfigRotateRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postAwsConfigRotateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAwsCreds - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAwsCreds('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAwsCreds', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostAwsCredsBodyParam = {
name: 'string',
role_arn: 'string',
role_session_name: 'string',
ttl: 3600
};
describe('#postAwsCreds - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAwsCreds('fakedata', 'fakedata', secretsPostAwsCredsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postAwsCreds', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAwsStsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAwsStsName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAwsStsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostAwsStsNameBodyParam = {
role_arn: 'string',
role_session_name: 'string',
ttl: 3600
};
describe('#postAwsStsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postAwsStsName('fakedata', 'fakedata', 'fakedata', secretsPostAwsStsNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postAwsStsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getAzureCredsRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getAzureCredsRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getAzureCredsRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getConsulConfigAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getConsulConfigAccess('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getConsulConfigAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostConsulConfigAccessBodyParam = {
address: 'string',
ca_cert: 'string',
client_cert: 'string',
client_key: 'string',
scheme: 'http',
token: 'string'
};
describe('#postConsulConfigAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postConsulConfigAccess('fakedata', 'fakedata', secretsPostConsulConfigAccessBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postConsulConfigAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getConsulCredsRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getConsulCredsRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getConsulCredsRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCubbyholePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCubbyholePath('fakedata', 'fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCubbyholePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postCubbyholePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCubbyholePath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCubbyholePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteCubbyholePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteCubbyholePath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteCubbyholePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getDatabaseConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getDatabaseConfigName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getDatabaseConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostDatabaseConfigNameBodyParam = {
allowed_roles: [
'string'
],
password_policy: 'string',
plugin_name: 'string',
root_rotation_statements: [
'string'
],
verify_connection: true
};
describe('#postDatabaseConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postDatabaseConfigName('fakedata', 'fakedata', 'fakedata', secretsPostDatabaseConfigNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postDatabaseConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteDatabaseConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteDatabaseConfigName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteDatabaseConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postDatabaseResetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postDatabaseResetName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postDatabaseResetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postDatabaseRotateRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postDatabaseRotateRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postDatabaseRotateRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postDatabaseRotateRootName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postDatabaseRotateRootName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postDatabaseRotateRootName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getDatabaseStaticCredsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getDatabaseStaticCredsName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getDatabaseStaticCredsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getDatabaseStaticRoles - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getDatabaseStaticRoles('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getDatabaseStaticRoles', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getDatabaseStaticRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getDatabaseStaticRolesName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getDatabaseStaticRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostDatabaseStaticRolesNameBodyParam = {
db_name: 'string',
rotation_period: 7,
rotation_statements: [
'string'
],
username: 'string'
};
describe('#postDatabaseStaticRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postDatabaseStaticRolesName('fakedata', 'fakedata', 'fakedata', secretsPostDatabaseStaticRolesNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postDatabaseStaticRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteDatabaseStaticRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteDatabaseStaticRolesName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteDatabaseStaticRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postGcpConfigRotateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpConfigRotateRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpConfigRotateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpKeyRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpKeyRoleset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpKeyRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpKeyRolesetBodyParam = {
key_algorithm: 'KEY_ALG_RSA_2048',
key_type: 'TYPE_GOOGLE_CREDENTIALS_FILE',
ttl: 7
};
describe('#postGcpKeyRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpKeyRoleset('fakedata', 'fakedata', 'fakedata', secretsPostGcpKeyRolesetBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpKeyRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpRolesetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpRolesetName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpRolesetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpRolesetNameBodyParam = {
bindings: 'string',
project: 'string',
secret_type: 'access_token',
token_scopes: [
'string'
]
};
describe('#postGcpRolesetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpRolesetName('fakedata', 'fakedata', 'fakedata', secretsPostGcpRolesetNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpRolesetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteGcpRolesetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteGcpRolesetName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteGcpRolesetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postGcpRolesetNameRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpRolesetNameRotate('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpRolesetNameRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postGcpRolesetNameRotateKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpRolesetNameRotateKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpRolesetNameRotateKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpRolesets - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpRolesets('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpRolesets', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpTokenRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpTokenRoleset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpTokenRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postGcpTokenRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpTokenRoleset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpTokenRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsDecryptKeyBodyParam = {
additional_authenticated_data: 'string',
ciphertext: 'string',
key_version: 1
};
describe('#postGcpkmsDecryptKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsDecryptKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsDecryptKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsDecryptKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsEncryptKeyBodyParam = {
additional_authenticated_data: 'string',
key_version: 7,
plaintext: 'string'
};
describe('#postGcpkmsEncryptKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsEncryptKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsEncryptKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsEncryptKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpkmsKeys - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpkmsKeys('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpkmsKeys', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpkmsKeysConfigKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpkmsKeysConfigKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpkmsKeysConfigKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsKeysConfigKeyBodyParam = {
max_version: 4,
min_version: 3
};
describe('#postGcpkmsKeysConfigKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsKeysConfigKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsKeysConfigKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsKeysConfigKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postGcpkmsKeysDeregisterKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsKeysDeregisterKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsKeysDeregisterKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteGcpkmsKeysDeregisterKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteGcpkmsKeysDeregisterKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteGcpkmsKeysDeregisterKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsKeysRegisterKeyBodyParam = {
crypto_key: 'string',
verify: true
};
describe('#postGcpkmsKeysRegisterKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsKeysRegisterKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsKeysRegisterKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsKeysRegisterKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postGcpkmsKeysRotateKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsKeysRotateKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsKeysRotateKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postGcpkmsKeysTrimKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsKeysTrimKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsKeysTrimKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteGcpkmsKeysTrimKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteGcpkmsKeysTrimKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteGcpkmsKeysTrimKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpkmsKeysKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpkmsKeysKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpkmsKeysKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsKeysKeyBodyParam = {
algorithm: 'string',
crypto_key: 'string',
key_ring: 'string',
labels: {},
protection_level: 'string',
purpose: 'string',
rotation_period: 1
};
describe('#postGcpkmsKeysKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsKeysKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsKeysKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsKeysKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteGcpkmsKeysKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteGcpkmsKeysKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteGcpkmsKeysKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getGcpkmsPubkeyKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getGcpkmsPubkeyKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getGcpkmsPubkeyKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsReencryptKeyBodyParam = {
additional_authenticated_data: 'string',
ciphertext: 'string',
key_version: 5
};
describe('#postGcpkmsReencryptKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsReencryptKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsReencryptKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsReencryptKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsSignKeyBodyParam = {
digest: 'string',
key_version: 4
};
describe('#postGcpkmsSignKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsSignKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsSignKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsSignKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostGcpkmsVerifyKeyBodyParam = {
digest: 'string',
key_version: 1,
signature: 'string'
};
describe('#postGcpkmsVerifyKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postGcpkmsVerifyKey('fakedata', 'fakedata', 'fakedata', secretsPostGcpkmsVerifyKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postGcpkmsVerifyKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getKvDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getKvDataPath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getKvDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostKvDataPathBodyParam = {
data: {},
options: {},
version: 6
};
describe('#postKvDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvDataPath('fakedata', 'fakedata', 'fakedata', secretsPostKvDataPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteKvDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteKvDataPath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteKvDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostKvDeletePathBodyParam = {
versions: [
7
]
};
describe('#postKvDeletePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvDeletePath('fakedata', 'fakedata', 'fakedata', secretsPostKvDeletePathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvDeletePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostKvDestroyPathBodyParam = {
versions: [
3
]
};
describe('#postKvDestroyPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvDestroyPath('fakedata', 'fakedata', 'fakedata', secretsPostKvDestroyPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvDestroyPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getKvMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getKvMetadataPath('fakedata', 'fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getKvMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostKvMetadataPathBodyParam = {
cas_required: true,
delete_version_after: 8,
max_versions: 8
};
describe('#postKvMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvMetadataPath('fakedata', 'fakedata', 'fakedata', secretsPostKvMetadataPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteKvMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteKvMetadataPath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteKvMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostKvUndeletePathBodyParam = {
versions: [
3
]
};
describe('#postKvUndeletePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postKvUndeletePath('fakedata', 'fakedata', 'fakedata', secretsPostKvUndeletePathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postKvUndeletePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getNomadConfigAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getNomadConfigAccess('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getNomadConfigAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostNomadConfigAccessBodyParam = {
address: 'string',
ca_cert: 'string',
client_cert: 'string',
client_key: 'string',
max_token_name_length: 4,
token: 'string'
};
describe('#postNomadConfigAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postNomadConfigAccess('fakedata', 'fakedata', secretsPostNomadConfigAccessBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postNomadConfigAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteNomadConfigAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteNomadConfigAccess('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteNomadConfigAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getNomadConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getNomadConfigLease('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getNomadConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostNomadConfigLeaseBodyParam = {
max_ttl: 4,
ttl: 9
};
describe('#postNomadConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postNomadConfigLease('fakedata', 'fakedata', secretsPostNomadConfigLeaseBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postNomadConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteNomadConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteNomadConfigLease('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteNomadConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getNomadRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getNomadRole('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getNomadRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getNomadRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getNomadRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getNomadRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostNomadRoleNameBodyParam = {
global: false,
policies: [
'string'
],
type: 'client'
};
describe('#postNomadRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postNomadRoleName('fakedata', 'fakedata', 'fakedata', secretsPostNomadRoleNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postNomadRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteNomadRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteNomadRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteNomadRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCa('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCaPem - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCaPem('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCaPem', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCaChain - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCaChain('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCaChain', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCertCaChain - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCertCaChain('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCertCaChain', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCertCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCertCrl('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCertCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCertSerial - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCertSerial('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCertSerial', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCerts - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCerts('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCerts', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiConfigCaBodyParam = {
pem_bundle: 'string'
};
describe('#postPkiConfigCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiConfigCa('fakedata', 'fakedata', secretsPostPkiConfigCaBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiConfigCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiConfigCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiConfigCrl('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiConfigCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiConfigCrlBodyParam = {
disable: true,
expiry: '72h'
};
describe('#postPkiConfigCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiConfigCrl('fakedata', 'fakedata', secretsPostPkiConfigCrlBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiConfigCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiConfigUrls - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiConfigUrls('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiConfigUrls', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiConfigUrlsBodyParam = {
crl_distribution_points: [
'string'
],
issuing_certificates: [
'string'
],
ocsp_servers: [
'string'
]
};
describe('#postPkiConfigUrls - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiConfigUrls('fakedata', 'fakedata', secretsPostPkiConfigUrlsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiConfigUrls', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCrl('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCrlPem - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCrlPem('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCrlPem', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getPkiCrlRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getPkiCrlRotate('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getPkiCrlRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiIntermediateGenerateExportedBodyParam = {
add_basic_constraints: true,
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
exclude_cn_from_sans: true,
format: 'der',
ip_sans: [
'string'
],
key_bits: 2048,
key_type: 'ec',
locality: [
'string'
],
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'pkcs8',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 9,
uri_sans: [
'string'
]
};
describe('#postPkiIntermediateGenerateExported - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiIntermediateGenerateExported('fakedata', 'fakedata', 'fakedata', secretsPostPkiIntermediateGenerateExportedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiIntermediateGenerateExported', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiIntermediateSetSignedBodyParam = {
certificate: 'string'
};
describe('#postPkiIntermediateSetSigned - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiIntermediateSetSigned('fakedata', 'fakedata', secretsPostPkiIntermediateSetSignedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiIntermediateSetSigned', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiIssueRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
exclude_cn_from_sans: false,
format: 'pem',
ip_sans: [
'string'
],
other_sans: [
'string'
],
private_key_format: 'pem',
serial_number: 'string',
ttl: 7,
uri_sans: [
'string'
]
};
describe('#postPkiIssueRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiIssueRole('fakedata', 'fakedata', 'fakedata', secretsPostPkiIssueRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiIssueRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiRevokeBodyParam = {
serial_number: 'string'
};
describe('#postPkiRevoke - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiRevoke('fakedata', 'fakedata', secretsPostPkiRevokeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiRevoke', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deletePkiRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deletePkiRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deletePkiRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiRootGenerateExportedBodyParam = {
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
exclude_cn_from_sans: true,
format: 'der',
ip_sans: [
'string'
],
key_bits: 2048,
key_type: 'rsa',
locality: [
'string'
],
max_path_length: -1,
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
permitted_dns_domains: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 4,
uri_sans: [
'string'
]
};
describe('#postPkiRootGenerateExported - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiRootGenerateExported('fakedata', 'fakedata', 'fakedata', secretsPostPkiRootGenerateExportedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiRootGenerateExported', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiRootSignIntermediateBodyParam = {
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
csr: 'string',
exclude_cn_from_sans: false,
format: 'der',
ip_sans: [
'string'
],
locality: [
'string'
],
max_path_length: -1,
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
permitted_dns_domains: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 1,
uri_sans: [
'string'
],
use_csr_values: false
};
describe('#postPkiRootSignIntermediate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiRootSignIntermediate('fakedata', 'fakedata', secretsPostPkiRootSignIntermediateBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiRootSignIntermediate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiRootSignSelfIssuedBodyParam = {
certificate: 'string'
};
describe('#postPkiRootSignSelfIssued - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiRootSignSelfIssued('fakedata', 'fakedata', secretsPostPkiRootSignSelfIssuedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiRootSignSelfIssued', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiSignVerbatimBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: true,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
format: 'pem',
ip_sans: [
'string'
],
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
other_sans: [
'string'
],
private_key_format: 'der',
role: 'string',
serial_number: 'string',
ttl: 7,
uri_sans: [
'string'
]
};
describe('#postPkiSignVerbatim - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSignVerbatim('fakedata', 'fakedata', secretsPostPkiSignVerbatimBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSignVerbatim', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiSignVerbatimRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: false,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
format: 'pem',
ip_sans: [
'string'
],
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
other_sans: [
'string'
],
private_key_format: 'pem',
serial_number: 'string',
ttl: 10,
uri_sans: [
'string'
]
};
describe('#postPkiSignVerbatimRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSignVerbatimRole('fakedata', 'fakedata', 'fakedata', secretsPostPkiSignVerbatimRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSignVerbatimRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiSignRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: true,
format: 'pem',
ip_sans: [
'string'
],
other_sans: [
'string'
],
private_key_format: 'pem',
serial_number: 'string',
ttl: 6,
uri_sans: [
'string'
]
};
describe('#postPkiSignRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiSignRole('fakedata', 'fakedata', 'fakedata', secretsPostPkiSignRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiSignRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostPkiTidyBodyParam = {
safety_buffer: 259200,
tidy_cert_store: false,
tidy_revocation_list: true,
tidy_revoked_certs: true
};
describe('#postPkiTidy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postPkiTidy('fakedata', 'fakedata', secretsPostPkiTidyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postPkiTidy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostRabbitmqConfigConnectionBodyParam = {
connection_uri: 'string',
password: 'string',
password_policy: 'string',
username: 'string',
verify_connection: true
};
describe('#postRabbitmqConfigConnection - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postRabbitmqConfigConnection('fakedata', 'fakedata', secretsPostRabbitmqConfigConnectionBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postRabbitmqConfigConnection', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getRabbitmqConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getRabbitmqConfigLease('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getRabbitmqConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostRabbitmqConfigLeaseBodyParam = {
max_ttl: 4,
ttl: 9
};
describe('#postRabbitmqConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postRabbitmqConfigLease('fakedata', 'fakedata', secretsPostRabbitmqConfigLeaseBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postRabbitmqConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineConfig('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineConfigBodyParam = {
anonymous_group_search: false,
binddn: 'string',
bindpass: 'string',
case_sensitive_names: true,
certificate: 'string',
client_tls_cert: 'string',
client_tls_key: 'string',
deny_null_bind: true,
discoverdn: true,
formatter: 'string',
groupattr: 'cn',
groupdn: 'string',
groupfilter: '(|(memberUid={{.Username}})(member={{.UserDN}})(uniqueMember={{.UserDN}}))',
insecure_tls: true,
last_rotation_tolerance: 5,
length: 64,
max_ttl: 2,
password_policy: 'string',
request_timeout: 10,
starttls: false,
tls_max_version: 'tls12',
tls_min_version: 'tls13',
ttl: 4,
upndomain: 'string',
url: 'ldap://127.0.0.1',
use_pre111_group_cn_behavior: true,
use_token_groups: true,
userattr: 'cn',
userdn: 'string'
};
describe('#postSecretEngineConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfig('fakedata', 'fakedata', secretsPostSecretEngineConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineConfig('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineCredsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineCredsName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineCredsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineLibrary - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineLibrary('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineLibrary', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineLibraryManageNameCheckInBodyParam = {
service_account_names: [
'string'
]
};
describe('#postSecretEngineLibraryManageNameCheckIn - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineLibraryManageNameCheckIn('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineLibraryManageNameCheckInBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineLibraryManageNameCheckIn', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineLibraryName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineLibraryName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineLibraryName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsUpdateSecretEngineLibraryNameBodyParam = {
disable_check_in_enforcement: true,
max_ttl: 86400,
service_account_names: [
'string'
],
ttl: 86400
};
describe('#updateSecretEngineLibraryName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.updateSecretEngineLibraryName('fakedata', 'fakedata', 'fakedata', secretsUpdateSecretEngineLibraryNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'updateSecretEngineLibraryName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineLibraryName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineLibraryName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineLibraryName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineLibraryNameCheckInBodyParam = {
service_account_names: [
'string'
]
};
describe('#postSecretEngineLibraryNameCheckIn - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineLibraryNameCheckIn('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineLibraryNameCheckInBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineLibraryNameCheckIn', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineLibraryNameCheckOutBodyParam = {
ttl: 9
};
describe('#postSecretEngineLibraryNameCheckOut - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineLibraryNameCheckOut('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineLibraryNameCheckOutBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineLibraryNameCheckOut', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineLibraryNameStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineLibraryNameStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineLibraryNameStatus', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineRotateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineRotateRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineRotateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineRotateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRotateRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRotateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineRole('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRoleNameBodyParam = {
inline_policies: 'string',
max_ttl: 9,
remote_policies: [
'string'
],
role_arn: 'string',
ttl: 3
};
describe('#postSecretEngineRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRoleName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineRoleNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineConfigLease('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineConfigLeaseBodyParam = {
lease: 'string',
lease_max: 'string'
};
describe('#postSecretEngineConfigLease - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfigLease('fakedata', 'fakedata', secretsPostSecretEngineConfigLeaseBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfigLease', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineConfigRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineConfigRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineConfigRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineConfigRootBodyParam = {
access_key: 'string',
iam_endpoint: 'string',
max_retries: -1,
region: 'string',
secret_key: 'string',
sts_endpoint: 'string'
};
describe('#postSecretEngineConfigRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfigRoot('fakedata', 'fakedata', secretsPostSecretEngineConfigRootBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfigRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineConfigRotateRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfigRotateRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfigRotateRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineCreds - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineCreds('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineCreds', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineCredsBodyParam = {
name: 'string',
role_arn: 'string',
role_session_name: 'string',
ttl: 3600
};
describe('#postSecretEngineCreds - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineCreds('fakedata', 'fakedata', secretsPostSecretEngineCredsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineCreds', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineStsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineStsName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineStsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineStsNameBodyParam = {
role_arn: 'string',
role_session_name: 'string',
ttl: 3600
};
describe('#postSecretEngineStsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineStsName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineStsNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineStsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineCredsRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineCredsRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineCredsRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineConfigAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineConfigAccess('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineConfigAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineConfigAccessBodyParam = {
address: 'string',
ca_cert: 'string',
client_cert: 'string',
client_key: 'string',
scheme: 'http',
token: 'string'
};
describe('#postSecretEngineConfigAccess - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfigAccess('fakedata', 'fakedata', secretsPostSecretEngineConfigAccessBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfigAccess', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEnginePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEnginePath('fakedata', 'fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEnginePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEnginePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEnginePath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEnginePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEnginePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEnginePath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEnginePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineConfigName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineConfigNameBodyParam = {
allowed_roles: [
'string'
],
password_policy: 'string',
plugin_name: 'string',
root_rotation_statements: [
'string'
],
verify_connection: true
};
describe('#postSecretEngineConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfigName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineConfigNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineConfigName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineResetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineResetName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineResetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineRotateRoleName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRotateRoleName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRotateRoleName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineRotateRootName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRotateRootName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRotateRootName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineStaticCredsName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineStaticCredsName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineStaticCredsName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineStaticRoles - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineStaticRoles('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineStaticRoles', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineStaticRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineStaticRolesName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineStaticRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineStaticRolesNameBodyParam = {
db_name: 'string',
rotation_period: 1,
rotation_statements: [
'string'
],
username: 'string'
};
describe('#postSecretEngineStaticRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineStaticRolesName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineStaticRolesNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineStaticRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineStaticRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineStaticRolesName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineStaticRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineKeyRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineKeyRoleset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineKeyRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeyRolesetBodyParam = {
key_algorithm: 'KEY_ALG_RSA_2048',
key_type: 'TYPE_GOOGLE_CREDENTIALS_FILE',
ttl: 1
};
describe('#postSecretEngineKeyRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeyRoleset('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeyRolesetBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeyRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineRolesetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineRolesetName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineRolesetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRolesetNameBodyParam = {
bindings: 'string',
project: 'string',
secret_type: 'access_token',
token_scopes: [
'string'
]
};
describe('#postSecretEngineRolesetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRolesetName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineRolesetNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRolesetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineRolesetName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineRolesetName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineRolesetName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineRolesetNameRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRolesetNameRotate('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRolesetNameRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineRolesetNameRotateKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRolesetNameRotateKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRolesetNameRotateKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineRolesets - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineRolesets('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineRolesets', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineTokenRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineTokenRoleset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineTokenRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineTokenRoleset - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineTokenRoleset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineTokenRoleset', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineDecryptKeyBodyParam = {
additional_authenticated_data: 'string',
ciphertext: 'string',
key_version: 2
};
describe('#postSecretEngineDecryptKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineDecryptKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineDecryptKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineDecryptKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineEncryptKeyBodyParam = {
additional_authenticated_data: 'string',
key_version: 6,
plaintext: 'string'
};
describe('#postSecretEngineEncryptKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineEncryptKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineEncryptKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineEncryptKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineKeys - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineKeys('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineKeys', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineKeysConfigKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineKeysConfigKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineKeysConfigKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeysConfigKeyBodyParam = {
max_version: 5,
min_version: 1
};
describe('#postSecretEngineKeysConfigKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysConfigKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeysConfigKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysConfigKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineKeysDeregisterKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysDeregisterKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysDeregisterKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineKeysDeregisterKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineKeysDeregisterKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineKeysDeregisterKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeysRegisterKeyBodyParam = {
crypto_key: 'string',
verify: true
};
describe('#postSecretEngineKeysRegisterKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysRegisterKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeysRegisterKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysRegisterKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineKeysRotateKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysRotateKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysRotateKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineKeysTrimKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysTrimKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysTrimKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineKeysTrimKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineKeysTrimKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineKeysTrimKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineKeysKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineKeysKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineKeysKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeysKeyBodyParam = {
algorithm: 'string',
crypto_key: 'string',
key_ring: 'string',
labels: {},
protection_level: 'string',
purpose: 'string',
rotation_period: 7
};
describe('#postSecretEngineKeysKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeysKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineKeysKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineKeysKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineKeysKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEnginePubkeyKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEnginePubkeyKey('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEnginePubkeyKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineReencryptKeyBodyParam = {
additional_authenticated_data: 'string',
ciphertext: 'string',
key_version: 7
};
describe('#postSecretEngineReencryptKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineReencryptKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineReencryptKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineReencryptKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineSignKeyBodyParam = {
digest: 'string',
key_version: 7
};
describe('#postSecretEngineSignKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineSignKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineSignKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineSignKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineVerifyKeyBodyParam = {
digest: 'string',
key_version: 1,
signature: 'string'
};
describe('#postSecretEngineVerifyKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineVerifyKey('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineVerifyKeyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineVerifyKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineDataPath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineDataPathBodyParam = {
data: {},
options: {},
version: 8
};
describe('#postSecretEngineDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineDataPath('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineDataPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineDataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineDataPath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineDataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineDeletePathBodyParam = {
versions: [
8
]
};
describe('#postSecretEngineDeletePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineDeletePath('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineDeletePathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineDeletePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineDestroyPathBodyParam = {
versions: [
5
]
};
describe('#postSecretEngineDestroyPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineDestroyPath('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineDestroyPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineDestroyPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineMetadataPath('fakedata', 'fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineMetadataPathBodyParam = {
cas_required: false,
delete_version_after: 9,
max_versions: 9
};
describe('#postSecretEngineMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineMetadataPath('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineMetadataPathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineMetadataPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineMetadataPath('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineMetadataPath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineUndeletePathBodyParam = {
versions: [
10
]
};
describe('#postSecretEngineUndeletePath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineUndeletePath('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineUndeletePathBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineUndeletePath', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineConfigConnectionBodyParam = {
connection_uri: 'string',
password: 'string',
password_policy: 'string',
username: 'string',
verify_connection: true
};
describe('#postSecretEngineConfigConnection - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfigConnection('fakedata', 'fakedata', secretsPostSecretEngineConfigConnectionBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfigConnection', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineConfigZeroaddress - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineConfigZeroaddress('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineConfigZeroaddress', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineConfigZeroaddressBodyParam = {
roles: [
'string'
]
};
describe('#postSecretEngineConfigZeroaddress - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineConfigZeroaddress('fakedata', 'fakedata', secretsPostSecretEngineConfigZeroaddressBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineConfigZeroaddress', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineConfigZeroaddress - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineConfigZeroaddress('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineConfigZeroaddress', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeysKeyNameBodyParam = {
key: 'string'
};
describe('#postSecretEngineKeysKeyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysKeyName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeysKeyNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysKeyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineKeysKeyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineKeysKeyName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineKeysKeyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineLookupBodyParam = {
ip: 'string'
};
describe('#postSecretEngineLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineLookup('fakedata', 'fakedata', secretsPostSecretEngineLookupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEnginePublicKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEnginePublicKey('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEnginePublicKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineVerifyBodyParam = {
otp: 'string'
};
describe('#postSecretEngineVerify - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineVerify('fakedata', 'fakedata', secretsPostSecretEngineVerifyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineVerify', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCa('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCaPem - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCaPem('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCaPem', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCaChain - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCaChain('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCaChain', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCertCaChain - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCertCaChain('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCertCaChain', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCertCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCertCrl('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCertCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertSerial - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertSerial('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertSerial', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCerts - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCerts('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCerts', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertConfigCaBodyParam = {
pem_bundle: 'string'
};
describe('#postCertConfigCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertConfigCa('fakedata', 'fakedata', secretsPostCertConfigCaBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertConfigCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertConfigCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertConfigCrl('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertConfigCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertConfigCrlBodyParam = {
disable: false,
expiry: '72h'
};
describe('#postCertConfigCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertConfigCrl('fakedata', 'fakedata', secretsPostCertConfigCrlBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertConfigCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertConfigUrls - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertConfigUrls('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertConfigUrls', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertConfigUrlsBodyParam = {
crl_distribution_points: [
'string'
],
issuing_certificates: [
'string'
],
ocsp_servers: [
'string'
]
};
describe('#postCertConfigUrls - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertConfigUrls('fakedata', 'fakedata', secretsPostCertConfigUrlsBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertConfigUrls', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCrl - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCrl('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCrl', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCrlPem - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCrlPem('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCrlPem', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertCrlRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertCrlRotate('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertCrlRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertImportQueue - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertImportQueue('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertImportQueue', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertImportQueueRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertImportQueueRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertImportQueueRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertIntermediateGenerateExportedBodyParam = {
add_basic_constraints: true,
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
exclude_cn_from_sans: true,
format: 'pem',
ip_sans: [
'string'
],
key_bits: 2048,
key_type: 'rsa',
locality: [
'string'
],
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 1,
uri_sans: [
'string'
]
};
describe('#postCertIntermediateGenerateExported - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertIntermediateGenerateExported('fakedata', 'fakedata', 'fakedata', secretsPostCertIntermediateGenerateExportedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertIntermediateGenerateExported', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertIntermediateSetSignedBodyParam = {
certificate: 'string'
};
describe('#postCertIntermediateSetSigned - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertIntermediateSetSigned('fakedata', 'fakedata', secretsPostCertIntermediateSetSignedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertIntermediateSetSigned', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertIssueRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
exclude_cn_from_sans: true,
format: 'pem',
ip_sans: [
'string'
],
other_sans: [
'string'
],
private_key_format: 'der',
serial_number: 'string',
ttl: 4,
uri_sans: [
'string'
]
};
describe('#postCertIssueRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertIssueRole('fakedata', 'fakedata', 'fakedata', secretsPostCertIssueRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertIssueRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertRevokeBodyParam = {
serial_number: 'string'
};
describe('#postCertRevoke - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertRevoke('fakedata', 'fakedata', secretsPostCertRevokeBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertRevoke', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineRoles - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineRoles('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineRoles', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineRolesName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRolesNameBodyParam = {
allow_any_name: false,
allow_bare_domains: true,
allow_glob_domains: true,
allow_ip_sans: true,
allow_localhost: true,
allow_subdomains: true,
allowed_domains: [
'string'
],
allowed_other_sans: [
'string'
],
allowed_serial_numbers: [
'string'
],
allowed_uri_sans: [
'string'
],
basic_constraints_valid_for_non_ca: true,
client_flag: true,
code_signing_flag: true,
country: [
'string'
],
email_protection_flag: false,
enforce_hostnames: true,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
generate_lease: true,
key_bits: 2048,
key_type: 'rsa',
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
locality: [
'string'
],
max_ttl: 3,
no_store: false,
not_before_duration: 30,
organization: [
'string'
],
ou: [
'string'
],
policy_identifiers: [
'string'
],
postal_code: [
'string'
],
province: [
'string'
],
require_cn: true,
server_flag: true,
street_address: [
'string'
],
ttl: 9,
use_csr_common_name: true,
use_csr_sans: true
};
describe('#postSecretEngineRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRolesName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineRolesNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineRolesName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineRolesName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineRolesName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteCertRoot - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteCertRoot('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteCertRoot', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertRootGenerateExportedBodyParam = {
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
exclude_cn_from_sans: true,
format: 'pem',
ip_sans: [
'string'
],
key_bits: 2048,
key_type: 'rsa',
locality: [
'string'
],
max_path_length: -1,
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
permitted_dns_domains: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 4,
uri_sans: [
'string'
]
};
describe('#postCertRootGenerateExported - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertRootGenerateExported('fakedata', 'fakedata', 'fakedata', secretsPostCertRootGenerateExportedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertRootGenerateExported', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertRootSignIntermediateBodyParam = {
alt_names: 'string',
common_name: 'string',
country: [
'string'
],
csr: 'string',
exclude_cn_from_sans: true,
format: 'pem',
ip_sans: [
'string'
],
locality: [
'string'
],
max_path_length: -1,
organization: [
'string'
],
other_sans: [
'string'
],
ou: [
'string'
],
permitted_dns_domains: [
'string'
],
postal_code: [
'string'
],
private_key_format: 'der',
province: [
'string'
],
serial_number: 'string',
street_address: [
'string'
],
ttl: 10,
uri_sans: [
'string'
],
use_csr_values: true
};
describe('#postCertRootSignIntermediate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertRootSignIntermediate('fakedata', 'fakedata', secretsPostCertRootSignIntermediateBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertRootSignIntermediate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertRootSignSelfIssuedBodyParam = {
certificate: 'string'
};
describe('#postCertRootSignSelfIssued - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertRootSignSelfIssued('fakedata', 'fakedata', secretsPostCertRootSignSelfIssuedBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertRootSignSelfIssued', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertShowVenafiRolePolicyMap - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertShowVenafiRolePolicyMap('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertShowVenafiRolePolicyMap', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertSignVerbatimBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: false,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
format: 'pem',
ip_sans: [
'string'
],
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
other_sans: [
'string'
],
private_key_format: 'der',
role: 'string',
serial_number: 'string',
ttl: 4,
uri_sans: [
'string'
]
};
describe('#postCertSignVerbatim - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertSignVerbatim('fakedata', 'fakedata', secretsPostCertSignVerbatimBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertSignVerbatim', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertSignVerbatimRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: true,
ext_key_usage: [],
ext_key_usage_oids: [
'string'
],
format: 'pem',
ip_sans: [
'string'
],
key_usage: [
'DigitalSignature',
'KeyAgreement',
'KeyEncipherment'
],
other_sans: [
'string'
],
private_key_format: 'der',
serial_number: 'string',
ttl: 2,
uri_sans: [
'string'
]
};
describe('#postCertSignVerbatimRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertSignVerbatimRole('fakedata', 'fakedata', 'fakedata', secretsPostCertSignVerbatimRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertSignVerbatimRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertSignRoleBodyParam = {
alt_names: 'string',
common_name: 'string',
csr: 'string',
exclude_cn_from_sans: false,
format: 'pem',
ip_sans: [
'string'
],
other_sans: [
'string'
],
private_key_format: 'der',
serial_number: 'string',
ttl: 2,
uri_sans: [
'string'
]
};
describe('#postCertSignRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertSignRole('fakedata', 'fakedata', 'fakedata', secretsPostCertSignRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertSignRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertTidyBodyParam = {
safety_buffer: 259200,
tidy_cert_store: false,
tidy_revocation_list: false,
tidy_revoked_certs: true
};
describe('#postCertTidy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertTidy('fakedata', 'fakedata', secretsPostCertTidyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertTidy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertVenafi - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertVenafi('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertVenafi', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertVenafiPolicy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertVenafiPolicy('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertVenafiPolicy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertVenafiPolicyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertVenafiPolicyName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertVenafiPolicyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertVenafiPolicyNameBodyParam = {
venafi_secret: 'string'
};
describe('#postCertVenafiPolicyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertVenafiPolicyName('fakedata', 'fakedata', 'fakedata', secretsPostCertVenafiPolicyNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertVenafiPolicyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteCertVenafiPolicyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteCertVenafiPolicyName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteCertVenafiPolicyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertVenafiPolicyNamePolicy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertVenafiPolicyNamePolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertVenafiPolicyNamePolicy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postCertVenafiPolicyNamePolicy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertVenafiPolicyNamePolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertVenafiPolicyNamePolicy', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertVenafiSyncPolicies - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertVenafiSyncPolicies('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertVenafiSyncPolicies', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getCertVenafiName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getCertVenafiName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getCertVenafiName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostCertVenafiNameBodyParam = {
access_token: 'string',
refresh_token: 'string',
tpp_password: 'string',
tpp_user: 'string',
url: 'string',
zone: 'string'
};
describe('#postCertVenafiName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postCertVenafiName('fakedata', 'fakedata', 'fakedata', secretsPostCertVenafiNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postCertVenafiName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteCertVenafiName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteCertVenafiName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteCertVenafiName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineCodeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineCodeName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineCodeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineCodeNameBodyParam = {
code: 'string'
};
describe('#postSecretEngineCodeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineCodeName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineCodeNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineCodeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineKeysName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeysNameBodyParam = {
account_name: 'string',
algorithm: 'SHA1',
digits: 6,
exported: true,
generate: true,
issuer: 'string',
key: 'string',
key_size: 20,
period: 30,
qr_size: 200,
skew: 1,
url: 'string'
};
describe('#postSecretEngineKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeysNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSecretEngineKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSecretEngineKeysName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSecretEngineKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineBackupName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineBackupName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineBackupName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineCacheConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineCacheConfig('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineCacheConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineCacheConfigBodyParam = {
size: 3
};
describe('#postSecretEngineCacheConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineCacheConfig('fakedata', 'fakedata', secretsPostSecretEngineCacheConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineCacheConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineDatakeyPlaintextNameBodyParam = {
bits: 256,
context: 'string',
key_version: 5,
nonce: 'string'
};
describe('#postSecretEngineDatakeyPlaintextName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineDatakeyPlaintextName('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineDatakeyPlaintextNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineDatakeyPlaintextName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineDecryptNameBodyParam = {
ciphertext: 'string',
context: 'string',
nonce: 'string'
};
describe('#postSecretEngineDecryptName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineDecryptName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineDecryptNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineDecryptName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineEncryptNameBodyParam = {
context: 'string',
convergent_encryption: false,
key_version: 8,
nonce: 'string',
plaintext: 'string',
type: 'aes256-gcm96'
};
describe('#postSecretEngineEncryptName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineEncryptName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineEncryptNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineEncryptName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineExportTypeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineExportTypeName('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineExportTypeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSecretEngineExportTypeNameVersion - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSecretEngineExportTypeNameVersion('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSecretEngineExportTypeNameVersion', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineHashBodyParam = {
algorithm: 'sha2-256',
format: 'hex',
input: 'string',
urlalgorithm: 'string'
};
describe('#postSecretEngineHash - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineHash('fakedata', 'fakedata', secretsPostSecretEngineHashBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineHash', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineHashUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
format: 'hex',
input: 'string'
};
describe('#postSecretEngineHashUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineHashUrlalgorithm('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineHashUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineHashUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineHmacNameBodyParam = {
algorithm: 'sha2-256',
input: 'string',
key_version: 3,
urlalgorithm: 'string'
};
describe('#postSecretEngineHmacName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineHmacName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineHmacNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineHmacName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineHmacNameUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
input: 'string',
key_version: 8
};
describe('#postSecretEngineHmacNameUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineHmacNameUrlalgorithm('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineHmacNameUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineHmacNameUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeysNameConfigBodyParam = {
allow_plaintext_backup: true,
deletion_allowed: false,
exportable: true,
min_decryption_version: 4,
min_encryption_version: 3
};
describe('#postSecretEngineKeysNameConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysNameConfig('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeysNameConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysNameConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postSecretEngineKeysNameRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysNameRotate('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysNameRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineKeysNameTrimBodyParam = {
min_available_version: 5
};
describe('#postSecretEngineKeysNameTrim - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineKeysNameTrim('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineKeysNameTrimBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineKeysNameTrim', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRandomBodyParam = {
bytes: 32,
format: 'base64',
urlbytes: 'string'
};
describe('#postSecretEngineRandom - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRandom('fakedata', 'fakedata', secretsPostSecretEngineRandomBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRandom', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRandomUrlbytesBodyParam = {
bytes: 32,
format: 'base64'
};
describe('#postSecretEngineRandomUrlbytes - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRandomUrlbytes('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineRandomUrlbytesBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRandomUrlbytes', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRestoreBodyParam = {
backup: 'string',
force: true,
name: 'string'
};
describe('#postSecretEngineRestore - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRestore('fakedata', 'fakedata', secretsPostSecretEngineRestoreBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRestore', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRestoreNameBodyParam = {
backup: 'string',
force: false
};
describe('#postSecretEngineRestoreName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRestoreName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineRestoreNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRestoreName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineRewrapNameBodyParam = {
ciphertext: 'string',
context: 'string',
key_version: 2,
nonce: 'string'
};
describe('#postSecretEngineRewrapName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineRewrapName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineRewrapNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineRewrapName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineSignNameBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
input: 'string',
key_version: 6,
marshaling_algorithm: 'asn1',
prehashed: false,
signature_algorithm: 'string',
urlalgorithm: 'string'
};
describe('#postSecretEngineSignName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineSignName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineSignNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineSignName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineSignNameUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
input: 'string',
key_version: 3,
marshaling_algorithm: 'asn1',
prehashed: true,
signature_algorithm: 'string'
};
describe('#postSecretEngineSignNameUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineSignNameUrlalgorithm('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineSignNameUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineSignNameUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineVerifyNameBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
hmac: 'string',
input: 'string',
marshaling_algorithm: 'asn1',
prehashed: true,
signature: 'string',
signature_algorithm: 'string',
urlalgorithm: 'string'
};
describe('#postSecretEngineVerifyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineVerifyName('fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineVerifyNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineVerifyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSecretEngineVerifyNameUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
hmac: 'string',
input: 'string',
marshaling_algorithm: 'asn1',
prehashed: true,
signature: 'string',
signature_algorithm: 'string'
};
describe('#postSecretEngineVerifyNameUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSecretEngineVerifyNameUrlalgorithm('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostSecretEngineVerifyNameUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSecretEngineVerifyNameUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSshConfigCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSshConfigCa('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSshConfigCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSshConfigCaBodyParam = {
generate_signing_key: true,
private_key: 'string',
public_key: 'string'
};
describe('#postSshConfigCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSshConfigCa('fakedata', 'fakedata', secretsPostSshConfigCaBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSshConfigCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSshConfigCa - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSshConfigCa('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSshConfigCa', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSshConfigZeroaddress - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSshConfigZeroaddress('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSshConfigZeroaddress', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSshConfigZeroaddressBodyParam = {
roles: [
'string'
]
};
describe('#postSshConfigZeroaddress - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSshConfigZeroaddress('fakedata', 'fakedata', secretsPostSshConfigZeroaddressBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSshConfigZeroaddress', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSshConfigZeroaddress - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSshConfigZeroaddress('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSshConfigZeroaddress', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSshCredsRoleBodyParam = {
ip: 'string',
username: 'string'
};
describe('#postSshCredsRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSshCredsRole('fakedata', 'fakedata', 'fakedata', secretsPostSshCredsRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSshCredsRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSshKeysKeyNameBodyParam = {
key: 'string'
};
describe('#postSshKeysKeyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSshKeysKeyName('fakedata', 'fakedata', 'fakedata', secretsPostSshKeysKeyNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSshKeysKeyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSshKeysKeyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSshKeysKeyName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteSshKeysKeyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSshLookupBodyParam = {
ip: 'string'
};
describe('#postSshLookup - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSshLookup('fakedata', 'fakedata', secretsPostSshLookupBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSshLookup', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSshPublicKey - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSshPublicKey('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getSshPublicKey', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSshSignRoleBodyParam = {
cert_type: 'user',
critical_options: {},
extensions: {},
key_id: 'string',
public_key: 'string',
ttl: 1,
valid_principals: 'string'
};
describe('#postSshSignRole - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSshSignRole('fakedata', 'fakedata', 'fakedata', secretsPostSshSignRoleBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSshSignRole', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostSshVerifyBodyParam = {
otp: 'string'
};
describe('#postSshVerify - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSshVerify('fakedata', 'fakedata', secretsPostSshVerifyBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postSshVerify', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTotpCodeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTotpCodeName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTotpCodeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTotpCodeNameBodyParam = {
code: 'string'
};
describe('#postTotpCodeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTotpCodeName('fakedata', 'fakedata', 'fakedata', secretsPostTotpCodeNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTotpCodeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTotpKeys - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTotpKeys('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTotpKeys', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTotpKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTotpKeysName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTotpKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTotpKeysNameBodyParam = {
account_name: 'string',
algorithm: 'SHA1',
digits: 6,
exported: true,
generate: false,
issuer: 'string',
key: 'string',
key_size: 20,
period: 30,
qr_size: 200,
skew: 1,
url: 'string'
};
describe('#postTotpKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTotpKeysName('fakedata', 'fakedata', 'fakedata', secretsPostTotpKeysNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTotpKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteTotpKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteTotpKeysName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteTotpKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTransitBackupName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTransitBackupName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTransitBackupName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTransitCacheConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTransitCacheConfig('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTransitCacheConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitCacheConfigBodyParam = {
size: 4
};
describe('#postTransitCacheConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitCacheConfig('fakedata', 'fakedata', secretsPostTransitCacheConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitCacheConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitDatakeyPlaintextNameBodyParam = {
bits: 256,
context: 'string',
key_version: 6,
nonce: 'string'
};
describe('#postTransitDatakeyPlaintextName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitDatakeyPlaintextName('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostTransitDatakeyPlaintextNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitDatakeyPlaintextName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitDecryptNameBodyParam = {
ciphertext: 'string',
context: 'string',
nonce: 'string'
};
describe('#postTransitDecryptName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitDecryptName('fakedata', 'fakedata', 'fakedata', secretsPostTransitDecryptNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitDecryptName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitEncryptNameBodyParam = {
context: 'string',
convergent_encryption: false,
key_version: 8,
nonce: 'string',
plaintext: 'string',
type: 'aes256-gcm96'
};
describe('#postTransitEncryptName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitEncryptName('fakedata', 'fakedata', 'fakedata', secretsPostTransitEncryptNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitEncryptName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTransitExportTypeName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTransitExportTypeName('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTransitExportTypeName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTransitExportTypeNameVersion - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTransitExportTypeNameVersion('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTransitExportTypeNameVersion', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitHashBodyParam = {
algorithm: 'sha2-256',
format: 'hex',
input: 'string',
urlalgorithm: 'string'
};
describe('#postTransitHash - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitHash('fakedata', 'fakedata', secretsPostTransitHashBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitHash', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitHashUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
format: 'hex',
input: 'string'
};
describe('#postTransitHashUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitHashUrlalgorithm('fakedata', 'fakedata', 'fakedata', secretsPostTransitHashUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitHashUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitHmacNameBodyParam = {
algorithm: 'sha2-256',
input: 'string',
key_version: 2,
urlalgorithm: 'string'
};
describe('#postTransitHmacName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitHmacName('fakedata', 'fakedata', 'fakedata', secretsPostTransitHmacNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitHmacName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitHmacNameUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
input: 'string',
key_version: 8
};
describe('#postTransitHmacNameUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitHmacNameUrlalgorithm('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostTransitHmacNameUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitHmacNameUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTransitKeys - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTransitKeys('fakedata', 'fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTransitKeys', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getTransitKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getTransitKeysName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'getTransitKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitKeysNameBodyParam = {
allow_plaintext_backup: false,
context: 'string',
convergent_encryption: true,
derived: true,
exportable: true,
type: 'aes256-gcm96'
};
describe('#postTransitKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitKeysName('fakedata', 'fakedata', 'fakedata', secretsPostTransitKeysNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteTransitKeysName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteTransitKeysName('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'deleteTransitKeysName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitKeysNameConfigBodyParam = {
allow_plaintext_backup: false,
deletion_allowed: false,
exportable: false,
min_decryption_version: 8,
min_encryption_version: 2
};
describe('#postTransitKeysNameConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitKeysNameConfig('fakedata', 'fakedata', 'fakedata', secretsPostTransitKeysNameConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitKeysNameConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#postTransitKeysNameRotate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitKeysNameRotate('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitKeysNameRotate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitKeysNameTrimBodyParam = {
min_available_version: 3
};
describe('#postTransitKeysNameTrim - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitKeysNameTrim('fakedata', 'fakedata', 'fakedata', secretsPostTransitKeysNameTrimBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitKeysNameTrim', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitRandomBodyParam = {
bytes: 32,
format: 'base64',
urlbytes: 'string'
};
describe('#postTransitRandom - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitRandom('fakedata', 'fakedata', secretsPostTransitRandomBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitRandom', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitRandomUrlbytesBodyParam = {
bytes: 32,
format: 'base64'
};
describe('#postTransitRandomUrlbytes - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitRandomUrlbytes('fakedata', 'fakedata', 'fakedata', secretsPostTransitRandomUrlbytesBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitRandomUrlbytes', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitRestoreBodyParam = {
backup: 'string',
force: false,
name: 'string'
};
describe('#postTransitRestore - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitRestore('fakedata', 'fakedata', secretsPostTransitRestoreBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitRestore', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitRestoreNameBodyParam = {
backup: 'string',
force: true
};
describe('#postTransitRestoreName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitRestoreName('fakedata', 'fakedata', 'fakedata', secretsPostTransitRestoreNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitRestoreName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitRewrapNameBodyParam = {
ciphertext: 'string',
context: 'string',
key_version: 4,
nonce: 'string'
};
describe('#postTransitRewrapName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitRewrapName('fakedata', 'fakedata', 'fakedata', secretsPostTransitRewrapNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitRewrapName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitSignNameBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
input: 'string',
key_version: 4,
marshaling_algorithm: 'asn1',
prehashed: false,
signature_algorithm: 'string',
urlalgorithm: 'string'
};
describe('#postTransitSignName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitSignName('fakedata', 'fakedata', 'fakedata', secretsPostTransitSignNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitSignName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitSignNameUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
input: 'string',
key_version: 2,
marshaling_algorithm: 'asn1',
prehashed: false,
signature_algorithm: 'string'
};
describe('#postTransitSignNameUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitSignNameUrlalgorithm('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostTransitSignNameUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitSignNameUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitVerifyNameBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
hmac: 'string',
input: 'string',
marshaling_algorithm: 'asn1',
prehashed: true,
signature: 'string',
signature_algorithm: 'string',
urlalgorithm: 'string'
};
describe('#postTransitVerifyName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitVerifyName('fakedata', 'fakedata', 'fakedata', secretsPostTransitVerifyNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitVerifyName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const secretsPostTransitVerifyNameUrlalgorithmBodyParam = {
algorithm: 'sha2-256',
context: 'string',
hash_algorithm: 'sha2-256',
hmac: 'string',
input: 'string',
marshaling_algorithm: 'asn1',
prehashed: false,
signature: 'string',
signature_algorithm: 'string'
};
describe('#postTransitVerifyNameUrlalgorithm - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postTransitVerifyNameUrlalgorithm('fakedata', 'fakedata', 'fakedata', 'fakedata', secretsPostTransitVerifyNameUrlalgorithmBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('Secrets', 'postTransitVerifyNameUrlalgorithm', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInternalCountersActivity - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInternalCountersActivity('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInternalCountersActivity', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInternalCountersActivityMonthly - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInternalCountersActivityMonthly('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInternalCountersActivityMonthly', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInternalCountersConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInternalCountersConfig('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInternalCountersConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysInternalCountersConfigBodyParam = {
default_report_months: 12,
enabled: 'default',
retention_months: 24
};
describe('#postSysInternalCountersConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysInternalCountersConfig('fakedata', systemPostSysInternalCountersConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysInternalCountersConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysInternalUiFeatureFlags - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysInternalUiFeatureFlags('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysInternalUiFeatureFlags', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofAllocs - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofAllocs('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofAllocs', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofBlock - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofBlock('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofBlock', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofMutex - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofMutex('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofMutex', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysPprofThreadcreate - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysPprofThreadcreate('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysPprofThreadcreate', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysRotateConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysRotateConfig('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysRotateConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysRotateConfigBodyParam = {
enabled: true,
interval: 9,
max_operations: 4
};
describe('#postSysRotateConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysRotateConfig('fakedata', systemPostSysRotateConfigBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysRotateConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysStorageRaftAutopilotConfiguration - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysStorageRaftAutopilotConfiguration('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysStorageRaftAutopilotConfiguration', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysStorageRaftAutopilotConfigurationBodyParam = {
cleanup_dead_servers: true,
dead_server_last_contact_threshold: 3,
last_contact_threshold: 2,
max_trailing_logs: 4,
min_quorum: 3,
server_stabilization_time: 8
};
describe('#postSysStorageRaftAutopilotConfiguration - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStorageRaftAutopilotConfiguration('fakedata', systemPostSysStorageRaftAutopilotConfigurationBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStorageRaftAutopilotConfiguration', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysStorageRaftAutopilotState - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysStorageRaftAutopilotState('fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysStorageRaftAutopilotState', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysStorageRaftSnapshotAutoConfig - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysStorageRaftSnapshotAutoConfig('fakedata', null, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysStorageRaftSnapshotAutoConfig', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysStorageRaftSnapshotAutoConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysStorageRaftSnapshotAutoConfigName('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysStorageRaftSnapshotAutoConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
const systemPostSysStorageRaftSnapshotAutoConfigNameBodyParam = {
aws_access_key_id: 'string',
aws_s3_bucket: 'string',
aws_s3_disable_tls: false,
aws_s3_enable_kms: false,
aws_s3_endpoint: 'string',
aws_s3_force_path_style: false,
aws_s3_kms_key: 'string',
aws_s3_region: 'string',
aws_s3_server_side_encryption: false,
aws_secret_access_key: 'string',
aws_session_token: 'string',
azure_account_key: 'string',
azure_account_name: 'string',
azure_blob_environment: 'AZUREPUBLICCLOUD',
azure_container_name: 'string',
azure_endpoint: 'string',
file_prefix: 'vault-snapshot',
google_disable_tls: false,
google_endpoint: 'string',
google_gcs_bucket: 'string',
google_service_account_key: 'string',
interval: 2,
local_max_space: 2,
path_prefix: 'string',
retain: 1,
storage_type: 'google-gcs'
};
describe('#postSysStorageRaftSnapshotAutoConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.postSysStorageRaftSnapshotAutoConfigName('fakedata', 'fakedata', systemPostSysStorageRaftSnapshotAutoConfigNameBodyParam, (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'postSysStorageRaftSnapshotAutoConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#deleteSysStorageRaftSnapshotAutoConfigName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.deleteSysStorageRaftSnapshotAutoConfigName('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'deleteSysStorageRaftSnapshotAutoConfigName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
describe('#getSysStorageRaftSnapshotAutoStatusName - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.getSysStorageRaftSnapshotAutoStatusName('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-hashicorp_vault-connectorRest-handleEndResponse', displayE);
} else {
runCommonAsserts(data, error);
}
saveMockData('System', 'getSysStorageRaftSnapshotAutoStatusName', 'default', data);
done();
} catch (err) {
log.error(`Test Failure: ${err}`);
done(err);
}
});
} catch (error) {
log.error(`Adapter Exception: ${error}`);
done(error);
}
}).timeout(attemptTimeout);
});
});
});