@itentialopensource/adapter-kubernetes
Version:
This adapter integrates with system described as: kubernetes.
32,365 lines • 1.16 MB
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-kubernetes',
type: 'Kubernetes',
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 Kubernetes = require('../../adapter');
// begin the testing - these should be pretty well defined between the describe and the it!
describe('[integration] Kubernetes Adapter Test', () => {
describe('Kubernetes Class Tests', () => {
const a = new Kubernetes(
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-kubernetes-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-kubernetes-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 ******************
-----------------------------------------------------------------------
-----------------------------------------------------------------------
*/
describe('#getCoreAPIVersions - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCoreAPIVersions((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getCoreV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCoreV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listCoreV1ComponentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1ComponentStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#readCoreV1ComponentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1ComponentStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.conditions));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1ConfigMapForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1ConfigMapForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1EndpointsForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1EndpointsForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1EventForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1EventForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1LimitRangeForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1LimitRangeForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1Namespace - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1Namespace('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1Namespace - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1Namespace('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createCoreV1NamespacedBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedBinding('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.target);
} 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('#deleteCoreV1CollectionNamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedConfigMap('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedConfigMap('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedConfigMap('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.binaryData);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteCoreV1NamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedConfigMap('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedConfigMap('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.binaryData);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#patchCoreV1NamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedConfigMap('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.binaryData);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#replaceCoreV1NamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedConfigMap('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.binaryData);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteCoreV1CollectionNamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedEndpoints('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedEndpoints('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedEndpoints('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.subsets));
} 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('#deleteCoreV1NamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedEndpoints('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedEndpoints('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.subsets));
} 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('#patchCoreV1NamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedEndpoints('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.subsets));
} 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('#replaceCoreV1NamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedEndpoints('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.subsets));
} 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('#deleteCoreV1CollectionNamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedEvent('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.count);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.firstTimestamp);
assert.equal('object', typeof data.response.involvedObject);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.lastTimestamp);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingComponent);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('object', typeof data.response.source);
assert.equal('string', data.response.type);
} 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('#deleteCoreV1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedEvent('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.count);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.firstTimestamp);
assert.equal('object', typeof data.response.involvedObject);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.lastTimestamp);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingComponent);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('object', typeof data.response.source);
assert.equal('string', data.response.type);
} 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('#patchCoreV1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.count);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.firstTimestamp);
assert.equal('object', typeof data.response.involvedObject);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.lastTimestamp);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingComponent);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('object', typeof data.response.source);
assert.equal('string', data.response.type);
} 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('#replaceCoreV1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedEvent('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.count);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.firstTimestamp);
assert.equal('object', typeof data.response.involvedObject);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.lastTimestamp);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingComponent);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('object', typeof data.response.source);
assert.equal('string', data.response.type);
} 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('#deleteCoreV1CollectionNamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedLimitRange('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedLimitRange('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedLimitRange('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteCoreV1NamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedLimitRange('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedLimitRange('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchCoreV1NamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedLimitRange('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceCoreV1NamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedLimitRange('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteCoreV1CollectionNamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedPersistentVolumeClaim('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedPersistentVolumeClaim('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedPersistentVolumeClaim('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1NamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedPersistentVolumeClaim('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedPersistentVolumeClaim('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedPersistentVolumeClaim('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedPersistentVolumeClaim('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readCoreV1NamespacedPersistentVolumeClaimStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedPersistentVolumeClaimStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedPersistentVolumeClaimStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedPersistentVolumeClaimStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedPersistentVolumeClaimStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedPersistentVolumeClaimStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1CollectionNamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedPod('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedPod('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedPod('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1NamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedPod('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedPod('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedPod('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedPod('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#connectCoreV1GetNamespacedPodAttach - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNamespacedPodAttach((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNamespacedPodAttach - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNamespacedPodAttach((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#createCoreV1NamespacedPodBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedPodBinding('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.target);
} 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('#createCoreV1NamespacedPodEviction - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedPodEviction('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.deleteOptions);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#connectCoreV1GetNamespacedPodExec - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNamespacedPodExec((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNamespacedPodExec - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNamespacedPodExec((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#readCoreV1NamespacedPodLog - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.readCoreV1NamespacedPodLog((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1GetNamespacedPodPortforward - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNamespacedPodPortforward((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNamespacedPodPortforward - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNamespacedPodPortforward((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1DeleteNamespacedPodProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1DeleteNamespacedPodProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1GetNamespacedPodProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNamespacedPodProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1HeadNamespacedPodProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1HeadNamespacedPodProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1OptionsNamespacedPodProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1OptionsNamespacedPodProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PatchNamespacedPodProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PatchNamespacedPodProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNamespacedPodProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNamespacedPodProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PutNamespacedPodProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PutNamespacedPodProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1DeleteNamespacedPodProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1DeleteNamespacedPodProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1GetNamespacedPodProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNamespacedPodProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1HeadNamespacedPodProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1HeadNamespacedPodProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1OptionsNamespacedPodProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1OptionsNamespacedPodProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PatchNamespacedPodProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PatchNamespacedPodProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNamespacedPodProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNamespacedPodProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PutNamespacedPodProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PutNamespacedPodProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#readCoreV1NamespacedPodStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedPodStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedPodStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedPodStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedPodStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedPodStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1CollectionNamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedPodTemplate('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedPodTemplate('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedPodTemplate('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.template);
} 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('#deleteCoreV1NamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedPodTemplate('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedPodTemplate('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.template);
} 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('#patchCoreV1NamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedPodTemplate('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.template);
} 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('#replaceCoreV1NamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedPodTemplate('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.template);
} 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('#deleteCoreV1CollectionNamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedReplicationController('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedReplicationController('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedReplicationController('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1NamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedReplicationController('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedReplicationController('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedReplicationController('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedReplicationController('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readCoreV1NamespacedReplicationControllerScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedReplicationControllerScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedReplicationControllerScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedReplicationControllerScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedReplicationControllerScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedReplicationControllerScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readCoreV1NamespacedReplicationControllerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedReplicationControllerStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedReplicationControllerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedReplicationControllerStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedReplicationControllerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedReplicationControllerStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1CollectionNamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedResourceQuota('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedResourceQuota('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedResourceQuota('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1NamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedResourceQuota('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedResourceQuota('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedResourceQuota('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedResourceQuota('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readCoreV1NamespacedResourceQuotaStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedResourceQuotaStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedResourceQuotaStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedResourceQuotaStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedResourceQuotaStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedResourceQuotaStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1CollectionNamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedSecret('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedSecret('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedSecret('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.stringData);
assert.equal('string', data.response.type);
} 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('#deleteCoreV1NamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedSecret('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedSecret('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.stringData);
assert.equal('string', data.response.type);
} 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('#patchCoreV1NamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedSecret('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.stringData);
assert.equal('string', data.response.type);
} 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('#replaceCoreV1NamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedSecret('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.stringData);
assert.equal('string', data.response.type);
} 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('#deleteCoreV1CollectionNamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNamespacedServiceAccount('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1NamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedServiceAccount('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedServiceAccount('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, data.response.automountServiceAccountToken);
assert.equal(true, Array.isArray(data.response.imagePullSecrets));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.secrets));
} 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('#deleteCoreV1NamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedServiceAccount('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedServiceAccount('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(false, data.response.automountServiceAccountToken);
assert.equal(true, Array.isArray(data.response.imagePullSecrets));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.secrets));
} 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('#patchCoreV1NamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedServiceAccount('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, data.response.automountServiceAccountToken);
assert.equal(true, Array.isArray(data.response.imagePullSecrets));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.secrets));
} 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('#replaceCoreV1NamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedServiceAccount('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(false, data.response.automountServiceAccountToken);
assert.equal(true, Array.isArray(data.response.imagePullSecrets));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.secrets));
} 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('#listCoreV1NamespacedService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1NamespacedService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1NamespacedService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1NamespacedService('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1NamespacedService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1NamespacedService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1NamespacedService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedService('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedService('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedService('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#connectCoreV1DeleteNamespacedServiceProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1DeleteNamespacedServiceProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1GetNamespacedServiceProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNamespacedServiceProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1HeadNamespacedServiceProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1HeadNamespacedServiceProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1OptionsNamespacedServiceProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1OptionsNamespacedServiceProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PatchNamespacedServiceProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PatchNamespacedServiceProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNamespacedServiceProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNamespacedServiceProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PutNamespacedServiceProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PutNamespacedServiceProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1DeleteNamespacedServiceProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1DeleteNamespacedServiceProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1GetNamespacedServiceProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNamespacedServiceProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1HeadNamespacedServiceProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1HeadNamespacedServiceProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1OptionsNamespacedServiceProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1OptionsNamespacedServiceProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PatchNamespacedServiceProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PatchNamespacedServiceProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNamespacedServiceProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNamespacedServiceProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PutNamespacedServiceProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PutNamespacedServiceProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#readCoreV1NamespacedServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespacedServiceStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespacedServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespacedServiceStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespacedServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespacedServiceStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1Namespace - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1Namespace('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1Namespace - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1Namespace('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1Namespace - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1Namespace('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1Namespace - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1Namespace('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespaceFinalize - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespaceFinalize('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readCoreV1NamespaceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NamespaceStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NamespaceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NamespaceStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NamespaceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NamespaceStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1CollectionNode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionNode('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1Node - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1Node('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1Node - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1Node('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1Node - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1Node('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1Node - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1Node('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1Node - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1Node('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1Node - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1Node('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#connectCoreV1DeleteNodeProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1DeleteNodeProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1GetNodeProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNodeProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1HeadNodeProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1HeadNodeProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1OptionsNodeProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1OptionsNodeProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PatchNodeProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PatchNodeProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNodeProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNodeProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PutNodeProxy - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PutNodeProxy((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1DeleteNodeProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1DeleteNodeProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1GetNodeProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1GetNodeProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1HeadNodeProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1HeadNodeProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1OptionsNodeProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1OptionsNodeProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PatchNodeProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PatchNodeProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PostNodeProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PostNodeProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#connectCoreV1PutNodeProxyWithPath - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.connectCoreV1PutNodeProxyWithPath((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#readCoreV1NodeStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1NodeStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1NodeStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1NodeStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1NodeStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1NodeStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#listCoreV1PersistentVolumeClaimForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1PersistentVolumeClaimForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteCoreV1CollectionPersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1CollectionPersistentVolume('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoreV1PersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1PersistentVolume('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoreV1PersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoreV1PersistentVolume('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCoreV1PersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoreV1PersistentVolume('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoreV1PersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1PersistentVolume('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1PersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1PersistentVolume('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1PersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1PersistentVolume('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readCoreV1PersistentVolumeStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoreV1PersistentVolumeStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCoreV1PersistentVolumeStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoreV1PersistentVolumeStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCoreV1PersistentVolumeStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoreV1PersistentVolumeStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#listCoreV1PodForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1PodForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1PodTemplateForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1PodTemplateForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1ReplicationControllerForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1ReplicationControllerForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1ResourceQuotaForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1ResourceQuotaForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1SecretForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1SecretForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1ServiceAccountForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1ServiceAccountForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listCoreV1ServiceForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoreV1ServiceForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchCoreV1ConfigMapListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1ConfigMapListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1EndpointsListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1EndpointsListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1EventListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1EventListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1LimitRangeListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1LimitRangeListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespaceList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespaceList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedConfigMapList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedConfigMapList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedConfigMap - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedConfigMap((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedEndpointsList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedEndpointsList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedEndpoints - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedEndpoints((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedEventList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedEventList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedEvent((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedLimitRangeList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedLimitRangeList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedLimitRange - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedLimitRange((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedPersistentVolumeClaimList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedPersistentVolumeClaimList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedPersistentVolumeClaim - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedPersistentVolumeClaim((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedPodList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedPodList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedPod - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedPod((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedPodTemplateList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedPodTemplateList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedPodTemplate - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedPodTemplate((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedReplicationControllerList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedReplicationControllerList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedReplicationController - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedReplicationController((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedResourceQuotaList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedResourceQuotaList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedResourceQuota - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedResourceQuota((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedSecretList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedSecretList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedSecret - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedSecret((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedServiceAccountList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedServiceAccountList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedServiceAccount - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedServiceAccount((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedServiceList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedServiceList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NamespacedService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NamespacedService((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1Namespace - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1Namespace((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1NodeList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1NodeList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1Node - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1Node((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1PersistentVolumeClaimListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1PersistentVolumeClaimListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1PersistentVolumeList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1PersistentVolumeList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1PersistentVolume - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1PersistentVolume((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1PodListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1PodListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1PodTemplateListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1PodTemplateListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1ReplicationControllerListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1ReplicationControllerListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1ResourceQuotaListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1ResourceQuotaListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1SecretListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1SecretListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1ServiceAccountListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1ServiceAccountListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoreV1ServiceListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoreV1ServiceListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAPIVersions - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAPIVersions((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.groups));
assert.equal('string', data.response.kind);
} 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('#getAdmissionregistrationAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAdmissionregistrationAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getAdmissionregistrationV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAdmissionregistrationV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAdmissionregistrationV1beta1MutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAdmissionregistrationV1beta1MutatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAdmissionregistrationV1beta1MutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAdmissionregistrationV1beta1MutatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAdmissionregistrationV1beta1MutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAdmissionregistrationV1beta1MutatingWebhookConfiguration('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#patchAdmissionregistrationV1beta1MutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAdmissionregistrationV1beta1MutatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAdmissionregistrationV1beta1ValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAdmissionregistrationV1beta1ValidatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAdmissionregistrationV1beta1ValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAdmissionregistrationV1beta1ValidatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAdmissionregistrationV1beta1ValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAdmissionregistrationV1beta1ValidatingWebhookConfiguration('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.webhooks));
} 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('#watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAdmissionregistrationV1beta1MutatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAdmissionregistrationV1beta1MutatingWebhookConfiguration((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getApiextensionsAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getApiextensionsAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getApiextensionsV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getApiextensionsV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteApiextensionsV1beta1CollectionCustomResourceDefinition - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteApiextensionsV1beta1CollectionCustomResourceDefinition('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listApiextensionsV1beta1CustomResourceDefinition - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.listApiextensionsV1beta1CustomResourceDefinition('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#createApiextensionsV1beta1CustomResourceDefinition - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.createApiextensionsV1beta1CustomResourceDefinition('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#deleteApiextensionsV1beta1CustomResourceDefinition - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteApiextensionsV1beta1CustomResourceDefinition('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readApiextensionsV1beta1CustomResourceDefinition - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.readApiextensionsV1beta1CustomResourceDefinition('fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#patchApiextensionsV1beta1CustomResourceDefinition - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.patchApiextensionsV1beta1CustomResourceDefinition('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#replaceApiextensionsV1beta1CustomResourceDefinition - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.replaceApiextensionsV1beta1CustomResourceDefinition('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#readApiextensionsV1beta1CustomResourceDefinitionStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.readApiextensionsV1beta1CustomResourceDefinitionStatus((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#patchApiextensionsV1beta1CustomResourceDefinitionStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.patchApiextensionsV1beta1CustomResourceDefinitionStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#replaceApiextensionsV1beta1CustomResourceDefinitionStatus - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.replaceApiextensionsV1beta1CustomResourceDefinitionStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#watchApiextensionsV1beta1CustomResourceDefinitionList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchApiextensionsV1beta1CustomResourceDefinitionList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchApiextensionsV1beta1CustomResourceDefinition - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchApiextensionsV1beta1CustomResourceDefinition((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getApiregistrationAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getApiregistrationAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getApiregistrationV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getApiregistrationV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteApiregistrationV1CollectionAPIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteApiregistrationV1CollectionAPIService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listApiregistrationV1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listApiregistrationV1APIService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createApiregistrationV1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createApiregistrationV1APIService('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteApiregistrationV1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteApiregistrationV1APIService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readApiregistrationV1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readApiregistrationV1APIService('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchApiregistrationV1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchApiregistrationV1APIService('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceApiregistrationV1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceApiregistrationV1APIService('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readApiregistrationV1APIServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readApiregistrationV1APIServiceStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchApiregistrationV1APIServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchApiregistrationV1APIServiceStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceApiregistrationV1APIServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceApiregistrationV1APIServiceStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchApiregistrationV1APIServiceList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchApiregistrationV1APIServiceList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchApiregistrationV1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchApiregistrationV1APIService((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getApiregistrationV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getApiregistrationV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteApiregistrationV1beta1CollectionAPIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteApiregistrationV1beta1CollectionAPIService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listApiregistrationV1beta1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listApiregistrationV1beta1APIService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createApiregistrationV1beta1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createApiregistrationV1beta1APIService('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteApiregistrationV1beta1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteApiregistrationV1beta1APIService('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readApiregistrationV1beta1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readApiregistrationV1beta1APIService('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchApiregistrationV1beta1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchApiregistrationV1beta1APIService('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceApiregistrationV1beta1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceApiregistrationV1beta1APIService('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readApiregistrationV1beta1APIServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readApiregistrationV1beta1APIServiceStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchApiregistrationV1beta1APIServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchApiregistrationV1beta1APIServiceStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceApiregistrationV1beta1APIServiceStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceApiregistrationV1beta1APIServiceStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchApiregistrationV1beta1APIServiceList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchApiregistrationV1beta1APIServiceList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchApiregistrationV1beta1APIService - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchApiregistrationV1beta1APIService((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAppsAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAppsAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getAppsV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAppsV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listAppsV1ControllerRevisionForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1ControllerRevisionForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listAppsV1DaemonSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1DaemonSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listAppsV1DeploymentForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1DeploymentForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteAppsV1CollectionNamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1CollectionNamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(2, data.response.revision);
} 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('#deleteAppsV1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedControllerRevision('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(10, data.response.revision);
} 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('#patchAppsV1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(5, data.response.revision);
} 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('#replaceAppsV1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(3, data.response.revision);
} 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('#deleteAppsV1CollectionNamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1CollectionNamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedDaemonSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedDaemonSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedDaemonSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedDaemonSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1CollectionNamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1CollectionNamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedDeployment('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedDeploymentScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedDeploymentStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1CollectionNamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1CollectionNamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedReplicaSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedReplicaSetScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedReplicaSetScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedReplicaSetScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedReplicaSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedReplicaSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedReplicaSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1CollectionNamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1CollectionNamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedStatefulSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedStatefulSetScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedStatefulSetScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedStatefulSetScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1NamespacedStatefulSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1NamespacedStatefulSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1NamespacedStatefulSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#listAppsV1ReplicaSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1ReplicaSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listAppsV1StatefulSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1StatefulSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchAppsV1ControllerRevisionListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1ControllerRevisionListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1DaemonSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1DaemonSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1DeploymentListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1DeploymentListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedControllerRevisionList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedControllerRevisionList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedControllerRevision((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedDaemonSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedDaemonSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedDaemonSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedDeploymentList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedDeploymentList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedDeployment((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedReplicaSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedReplicaSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedReplicaSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedStatefulSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedStatefulSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1NamespacedStatefulSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1ReplicaSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1ReplicaSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1StatefulSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1StatefulSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAppsV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAppsV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listAppsV1beta1ControllerRevisionForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta1ControllerRevisionForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listAppsV1beta1DeploymentForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta1DeploymentForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteAppsV1beta1CollectionNamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta1CollectionNamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(1, data.response.revision);
} 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('#deleteAppsV1beta1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta1NamespacedControllerRevision('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(7, data.response.revision);
} 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('#patchAppsV1beta1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(9, data.response.revision);
} 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('#replaceAppsV1beta1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta1NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(1, data.response.revision);
} 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('#deleteAppsV1beta1CollectionNamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta1CollectionNamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta1NamespacedDeployment('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createAppsV1beta1NamespacedDeploymentRollback - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta1NamespacedDeploymentRollback('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta1NamespacedDeploymentScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta1NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta1NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta1NamespacedDeploymentStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta1NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta1NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta1CollectionNamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta1CollectionNamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta1NamespacedStatefulSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta1NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta1NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta1NamespacedStatefulSetScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta1NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta1NamespacedStatefulSetScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta1NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta1NamespacedStatefulSetScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta1NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta1NamespacedStatefulSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta1NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta1NamespacedStatefulSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta1NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta1NamespacedStatefulSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#listAppsV1beta1StatefulSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta1StatefulSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchAppsV1beta1ControllerRevisionListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1ControllerRevisionListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1DeploymentListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1DeploymentListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1NamespacedControllerRevisionList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1NamespacedControllerRevisionList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1NamespacedControllerRevision((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1NamespacedDeploymentList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1NamespacedDeploymentList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1NamespacedDeployment((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1NamespacedStatefulSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1NamespacedStatefulSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1NamespacedStatefulSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta1StatefulSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta1StatefulSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAppsV1beta2APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAppsV1beta2APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listAppsV1beta2ControllerRevisionForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2ControllerRevisionForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listAppsV1beta2DaemonSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2DaemonSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listAppsV1beta2DeploymentForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2DeploymentForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteAppsV1beta2CollectionNamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2CollectionNamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta2NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta2NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta2NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(9, data.response.revision);
} 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('#deleteAppsV1beta2NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta2NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedControllerRevision('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(10, data.response.revision);
} 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('#patchAppsV1beta2NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(6, data.response.revision);
} 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('#replaceAppsV1beta2NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedControllerRevision('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('object', typeof data.response.data);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(7, data.response.revision);
} 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('#deleteAppsV1beta2CollectionNamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2CollectionNamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta2NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta2NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta2NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta2NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta2NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedDaemonSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta2NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedDaemonSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedDaemonSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedDaemonSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta2CollectionNamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2CollectionNamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta2NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta2NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta2NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta2NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta2NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedDeployment('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta2NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedDeploymentScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta2NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedDeploymentStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta2CollectionNamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2CollectionNamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta2NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta2NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta2NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta2NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta2NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedReplicaSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta2NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedReplicaSetScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedReplicaSetScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedReplicaSetScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta2NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedReplicaSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedReplicaSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedReplicaSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta2CollectionNamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2CollectionNamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAppsV1beta2NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAppsV1beta2NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAppsV1beta2NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAppsV1beta2NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAppsV1beta2NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAppsV1beta2NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedStatefulSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedStatefulSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta2NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedStatefulSetScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedStatefulSetScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedStatefulSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedStatefulSetScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAppsV1beta2NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAppsV1beta2NamespacedStatefulSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAppsV1beta2NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAppsV1beta2NamespacedStatefulSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAppsV1beta2NamespacedStatefulSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAppsV1beta2NamespacedStatefulSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#listAppsV1beta2ReplicaSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2ReplicaSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listAppsV1beta2StatefulSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAppsV1beta2StatefulSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchAppsV1beta2ControllerRevisionListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2ControllerRevisionListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2DaemonSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2DaemonSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2DeploymentListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2DeploymentListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedControllerRevisionList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedControllerRevisionList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedControllerRevision - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedControllerRevision((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedDaemonSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedDaemonSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedDaemonSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedDeploymentList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedDeploymentList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedDeployment((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedReplicaSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedReplicaSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedReplicaSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedStatefulSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedStatefulSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2NamespacedStatefulSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2NamespacedStatefulSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2ReplicaSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2ReplicaSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAppsV1beta2StatefulSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAppsV1beta2StatefulSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAuditregistrationAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuditregistrationAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getAuditregistrationV1alpha1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuditregistrationV1alpha1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteAuditregistrationV1alpha1CollectionAuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAuditregistrationV1alpha1CollectionAuditSink('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAuditregistrationV1alpha1AuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAuditregistrationV1alpha1AuditSink('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAuditregistrationV1alpha1AuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuditregistrationV1alpha1AuditSink('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteAuditregistrationV1alpha1AuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAuditregistrationV1alpha1AuditSink('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAuditregistrationV1alpha1AuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAuditregistrationV1alpha1AuditSink('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchAuditregistrationV1alpha1AuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAuditregistrationV1alpha1AuditSink('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceAuditregistrationV1alpha1AuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAuditregistrationV1alpha1AuditSink('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#watchAuditregistrationV1alpha1AuditSinkList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAuditregistrationV1alpha1AuditSinkList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAuditregistrationV1alpha1AuditSink - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAuditregistrationV1alpha1AuditSink((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAuthenticationAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuthenticationAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getAuthenticationV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuthenticationV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#createAuthenticationV1TokenReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthenticationV1TokenReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#getAuthenticationV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuthenticationV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#createAuthenticationV1beta1TokenReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthenticationV1beta1TokenReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#getAuthorizationAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuthorizationAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getAuthorizationV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuthorizationV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#createAuthorizationV1NamespacedLocalSubjectAccessReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1NamespacedLocalSubjectAccessReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createAuthorizationV1SelfSubjectAccessReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1SelfSubjectAccessReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createAuthorizationV1SelfSubjectRulesReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1SelfSubjectRulesReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createAuthorizationV1SubjectAccessReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1SubjectAccessReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#getAuthorizationV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAuthorizationV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#createAuthorizationV1beta1NamespacedLocalSubjectAccessReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1beta1NamespacedLocalSubjectAccessReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createAuthorizationV1beta1SelfSubjectAccessReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1beta1SelfSubjectAccessReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createAuthorizationV1beta1SelfSubjectRulesReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1beta1SelfSubjectRulesReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createAuthorizationV1beta1SubjectAccessReview - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAuthorizationV1beta1SubjectAccessReview('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#getAutoscalingAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAutoscalingAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getAutoscalingV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAutoscalingV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAutoscalingV1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAutoscalingV1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAutoscalingV1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAutoscalingV1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAutoscalingV1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAutoscalingV1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAutoscalingV1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAutoscalingV1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAutoscalingV1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAutoscalingV1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAutoscalingV1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAutoscalingV1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAutoscalingV1NamespacedHorizontalPodAutoscalerList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV1NamespacedHorizontalPodAutoscalerList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAutoscalingV1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV1NamespacedHorizontalPodAutoscaler((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAutoscalingV2beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAutoscalingV2beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getAutoscalingV2beta2APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getAutoscalingV2beta2APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getBatchAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getBatchAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getBatchV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getBatchV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listBatchV1JobForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listBatchV1JobForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteBatchV1CollectionNamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteBatchV1CollectionNamespacedJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listBatchV1NamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listBatchV1NamespacedJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createBatchV1NamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createBatchV1NamespacedJob('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteBatchV1NamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteBatchV1NamespacedJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readBatchV1NamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readBatchV1NamespacedJob('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchBatchV1NamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchBatchV1NamespacedJob('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceBatchV1NamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceBatchV1NamespacedJob('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readBatchV1NamespacedJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readBatchV1NamespacedJobStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchBatchV1NamespacedJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchBatchV1NamespacedJobStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceBatchV1NamespacedJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceBatchV1NamespacedJobStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchBatchV1JobListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV1JobListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchBatchV1NamespacedJobList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV1NamespacedJobList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchBatchV1NamespacedJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV1NamespacedJob((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getBatchV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getBatchV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listBatchV1beta1CronJobForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listBatchV1beta1CronJobForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteBatchV1beta1CollectionNamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteBatchV1beta1CollectionNamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listBatchV1beta1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listBatchV1beta1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createBatchV1beta1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createBatchV1beta1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteBatchV1beta1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteBatchV1beta1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readBatchV1beta1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readBatchV1beta1NamespacedCronJob('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchBatchV1beta1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchBatchV1beta1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceBatchV1beta1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceBatchV1beta1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readBatchV1beta1NamespacedCronJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readBatchV1beta1NamespacedCronJobStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchBatchV1beta1NamespacedCronJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchBatchV1beta1NamespacedCronJobStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceBatchV1beta1NamespacedCronJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceBatchV1beta1NamespacedCronJobStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchBatchV1beta1CronJobListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV1beta1CronJobListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchBatchV1beta1NamespacedCronJobList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV1beta1NamespacedCronJobList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchBatchV1beta1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV1beta1NamespacedCronJob((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getBatchV2alpha1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getBatchV2alpha1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listBatchV2alpha1CronJobForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listBatchV2alpha1CronJobForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteBatchV2alpha1CollectionNamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteBatchV2alpha1CollectionNamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listBatchV2alpha1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listBatchV2alpha1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createBatchV2alpha1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createBatchV2alpha1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteBatchV2alpha1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteBatchV2alpha1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readBatchV2alpha1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readBatchV2alpha1NamespacedCronJob('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchBatchV2alpha1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchBatchV2alpha1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceBatchV2alpha1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceBatchV2alpha1NamespacedCronJob('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readBatchV2alpha1NamespacedCronJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readBatchV2alpha1NamespacedCronJobStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchBatchV2alpha1NamespacedCronJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchBatchV2alpha1NamespacedCronJobStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceBatchV2alpha1NamespacedCronJobStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceBatchV2alpha1NamespacedCronJobStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchBatchV2alpha1CronJobListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV2alpha1CronJobListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchBatchV2alpha1NamespacedCronJobList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV2alpha1NamespacedCronJobList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchBatchV2alpha1NamespacedCronJob - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchBatchV2alpha1NamespacedCronJob((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getCertificatesAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCertificatesAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getCertificatesV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCertificatesV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteCertificatesV1beta1CollectionCertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCertificatesV1beta1CollectionCertificateSigningRequest('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCertificatesV1beta1CertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCertificatesV1beta1CertificateSigningRequest('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCertificatesV1beta1CertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCertificatesV1beta1CertificateSigningRequest('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteCertificatesV1beta1CertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCertificatesV1beta1CertificateSigningRequest('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCertificatesV1beta1CertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCertificatesV1beta1CertificateSigningRequest('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCertificatesV1beta1CertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCertificatesV1beta1CertificateSigningRequest('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCertificatesV1beta1CertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCertificatesV1beta1CertificateSigningRequest('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCertificatesV1beta1CertificateSigningRequestApproval - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCertificatesV1beta1CertificateSigningRequestApproval('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readCertificatesV1beta1CertificateSigningRequestStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCertificatesV1beta1CertificateSigningRequestStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchCertificatesV1beta1CertificateSigningRequestStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCertificatesV1beta1CertificateSigningRequestStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceCertificatesV1beta1CertificateSigningRequestStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCertificatesV1beta1CertificateSigningRequestStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchCertificatesV1beta1CertificateSigningRequestList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCertificatesV1beta1CertificateSigningRequestList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCertificatesV1beta1CertificateSigningRequest - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCertificatesV1beta1CertificateSigningRequest((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getCoordinationAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCoordinationAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getCoordinationV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCoordinationV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listCoordinationV1LeaseForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoordinationV1LeaseForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteCoordinationV1CollectionNamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoordinationV1CollectionNamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoordinationV1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoordinationV1NamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoordinationV1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoordinationV1NamespacedLease('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteCoordinationV1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoordinationV1NamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoordinationV1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoordinationV1NamespacedLease('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchCoordinationV1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoordinationV1NamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceCoordinationV1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoordinationV1NamespacedLease('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#watchCoordinationV1LeaseListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoordinationV1LeaseListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoordinationV1NamespacedLeaseList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoordinationV1NamespacedLeaseList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoordinationV1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoordinationV1NamespacedLease((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getCoordinationV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCoordinationV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listCoordinationV1beta1LeaseForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoordinationV1beta1LeaseForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteCoordinationV1beta1CollectionNamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoordinationV1beta1CollectionNamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listCoordinationV1beta1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listCoordinationV1beta1NamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createCoordinationV1beta1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createCoordinationV1beta1NamespacedLease('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteCoordinationV1beta1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteCoordinationV1beta1NamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readCoordinationV1beta1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readCoordinationV1beta1NamespacedLease('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchCoordinationV1beta1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchCoordinationV1beta1NamespacedLease('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceCoordinationV1beta1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceCoordinationV1beta1NamespacedLease('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#watchCoordinationV1beta1LeaseListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoordinationV1beta1LeaseListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoordinationV1beta1NamespacedLeaseList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoordinationV1beta1NamespacedLeaseList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchCoordinationV1beta1NamespacedLease - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchCoordinationV1beta1NamespacedLease((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getEventsAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getEventsAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getEventsV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getEventsV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listEventsV1beta1EventForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listEventsV1beta1EventForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteEventsV1beta1CollectionNamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteEventsV1beta1CollectionNamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listEventsV1beta1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listEventsV1beta1NamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createEventsV1beta1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createEventsV1beta1NamespacedEvent('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.deprecatedCount);
assert.equal('string', data.response.deprecatedFirstTimestamp);
assert.equal('string', data.response.deprecatedLastTimestamp);
assert.equal('object', typeof data.response.deprecatedSource);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.note);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.regarding);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingController);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('string', data.response.type);
} 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('#deleteEventsV1beta1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteEventsV1beta1NamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readEventsV1beta1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readEventsV1beta1NamespacedEvent('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.deprecatedCount);
assert.equal('string', data.response.deprecatedFirstTimestamp);
assert.equal('string', data.response.deprecatedLastTimestamp);
assert.equal('object', typeof data.response.deprecatedSource);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.note);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.regarding);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingController);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('string', data.response.type);
} 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('#patchEventsV1beta1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchEventsV1beta1NamespacedEvent('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.deprecatedCount);
assert.equal('string', data.response.deprecatedFirstTimestamp);
assert.equal('string', data.response.deprecatedLastTimestamp);
assert.equal('object', typeof data.response.deprecatedSource);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.note);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.regarding);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingController);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('string', data.response.type);
} 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('#replaceEventsV1beta1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceEventsV1beta1NamespacedEvent('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.action);
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.deprecatedCount);
assert.equal('string', data.response.deprecatedFirstTimestamp);
assert.equal('string', data.response.deprecatedLastTimestamp);
assert.equal('object', typeof data.response.deprecatedSource);
assert.equal('string', data.response.eventTime);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.note);
assert.equal('string', data.response.reason);
assert.equal('object', typeof data.response.regarding);
assert.equal('object', typeof data.response.related);
assert.equal('string', data.response.reportingController);
assert.equal('string', data.response.reportingInstance);
assert.equal('object', typeof data.response.series);
assert.equal('string', data.response.type);
} 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('#watchEventsV1beta1EventListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchEventsV1beta1EventListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchEventsV1beta1NamespacedEventList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchEventsV1beta1NamespacedEventList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchEventsV1beta1NamespacedEvent - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchEventsV1beta1NamespacedEvent((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getExtensionsAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getExtensionsAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getExtensionsV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getExtensionsV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listExtensionsV1beta1DaemonSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1DaemonSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listExtensionsV1beta1DeploymentForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1DeploymentForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listExtensionsV1beta1IngressForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1IngressForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteExtensionsV1beta1CollectionNamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1CollectionNamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listExtensionsV1beta1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createExtensionsV1beta1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createExtensionsV1beta1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteExtensionsV1beta1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readExtensionsV1beta1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedDaemonSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedDaemonSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readExtensionsV1beta1NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedDaemonSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedDaemonSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedDaemonSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedDaemonSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteExtensionsV1beta1CollectionNamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1CollectionNamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listExtensionsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createExtensionsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createExtensionsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteExtensionsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readExtensionsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedDeployment('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedDeployment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#createExtensionsV1beta1NamespacedDeploymentRollback - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createExtensionsV1beta1NamespacedDeploymentRollback('fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readExtensionsV1beta1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedDeploymentScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedDeploymentScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedDeploymentScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readExtensionsV1beta1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedDeploymentStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedDeploymentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedDeploymentStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteExtensionsV1beta1CollectionNamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1CollectionNamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listExtensionsV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createExtensionsV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createExtensionsV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteExtensionsV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readExtensionsV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedIngress('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readExtensionsV1beta1NamespacedIngressStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedIngressStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedIngressStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedIngressStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedIngressStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedIngressStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteExtensionsV1beta1CollectionNamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1CollectionNamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listExtensionsV1beta1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createExtensionsV1beta1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createExtensionsV1beta1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteExtensionsV1beta1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readExtensionsV1beta1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedNetworkPolicy('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchExtensionsV1beta1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceExtensionsV1beta1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteExtensionsV1beta1CollectionNamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1CollectionNamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listExtensionsV1beta1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createExtensionsV1beta1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createExtensionsV1beta1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteExtensionsV1beta1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readExtensionsV1beta1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedReplicaSet('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedReplicaSet('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readExtensionsV1beta1NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedReplicaSetScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedReplicaSetScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedReplicaSetScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedReplicaSetScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readExtensionsV1beta1NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedReplicaSetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedReplicaSetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedReplicaSetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedReplicaSetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readExtensionsV1beta1NamespacedReplicationControllerDummyScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1NamespacedReplicationControllerDummyScale((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchExtensionsV1beta1NamespacedReplicationControllerDummyScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1NamespacedReplicationControllerDummyScale('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceExtensionsV1beta1NamespacedReplicationControllerDummyScale - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1NamespacedReplicationControllerDummyScale('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#listExtensionsV1beta1NetworkPolicyForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1NetworkPolicyForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteExtensionsV1beta1CollectionPodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1CollectionPodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listExtensionsV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createExtensionsV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createExtensionsV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteExtensionsV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteExtensionsV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readExtensionsV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readExtensionsV1beta1PodSecurityPolicy('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchExtensionsV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchExtensionsV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceExtensionsV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceExtensionsV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#listExtensionsV1beta1ReplicaSetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listExtensionsV1beta1ReplicaSetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchExtensionsV1beta1DaemonSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1DaemonSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1DeploymentListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1DeploymentListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1IngressListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1IngressListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedDaemonSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedDaemonSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedDaemonSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedDaemonSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedDeploymentList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedDeploymentList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedDeployment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedDeployment((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedIngressList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedIngressList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedIngress((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedNetworkPolicyList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedNetworkPolicyList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedNetworkPolicy((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedReplicaSetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedReplicaSetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NamespacedReplicaSet - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NamespacedReplicaSet((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1NetworkPolicyListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1NetworkPolicyListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1PodSecurityPolicyList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1PodSecurityPolicyList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1PodSecurityPolicy((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchExtensionsV1beta1ReplicaSetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchExtensionsV1beta1ReplicaSetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getNetworkingAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getNetworkingAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getNetworkingV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getNetworkingV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteNetworkingV1CollectionNamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNetworkingV1CollectionNamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listNetworkingV1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listNetworkingV1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createNetworkingV1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createNetworkingV1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteNetworkingV1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNetworkingV1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readNetworkingV1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readNetworkingV1NamespacedNetworkPolicy('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchNetworkingV1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchNetworkingV1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceNetworkingV1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceNetworkingV1NamespacedNetworkPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#listNetworkingV1NetworkPolicyForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listNetworkingV1NetworkPolicyForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchNetworkingV1NamespacedNetworkPolicyList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNetworkingV1NamespacedNetworkPolicyList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchNetworkingV1NamespacedNetworkPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNetworkingV1NamespacedNetworkPolicy((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchNetworkingV1NetworkPolicyListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNetworkingV1NetworkPolicyListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getNetworkingV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getNetworkingV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#listNetworkingV1beta1IngressForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listNetworkingV1beta1IngressForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteNetworkingV1beta1CollectionNamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNetworkingV1beta1CollectionNamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listNetworkingV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listNetworkingV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createNetworkingV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createNetworkingV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteNetworkingV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNetworkingV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readNetworkingV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readNetworkingV1beta1NamespacedIngress('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchNetworkingV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchNetworkingV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceNetworkingV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceNetworkingV1beta1NamespacedIngress('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readNetworkingV1beta1NamespacedIngressStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readNetworkingV1beta1NamespacedIngressStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchNetworkingV1beta1NamespacedIngressStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchNetworkingV1beta1NamespacedIngressStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceNetworkingV1beta1NamespacedIngressStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceNetworkingV1beta1NamespacedIngressStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchNetworkingV1beta1IngressListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNetworkingV1beta1IngressListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchNetworkingV1beta1NamespacedIngressList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNetworkingV1beta1NamespacedIngressList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchNetworkingV1beta1NamespacedIngress - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNetworkingV1beta1NamespacedIngress((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getNodeAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getNodeAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getNodeV1alpha1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getNodeV1alpha1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteNodeV1alpha1CollectionRuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNodeV1alpha1CollectionRuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listNodeV1alpha1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listNodeV1alpha1RuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createNodeV1alpha1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createNodeV1alpha1RuntimeClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteNodeV1alpha1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNodeV1alpha1RuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readNodeV1alpha1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readNodeV1alpha1RuntimeClass('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchNodeV1alpha1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchNodeV1alpha1RuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceNodeV1alpha1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceNodeV1alpha1RuntimeClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#watchNodeV1alpha1RuntimeClassList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNodeV1alpha1RuntimeClassList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchNodeV1alpha1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNodeV1alpha1RuntimeClass((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getNodeV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getNodeV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteNodeV1beta1CollectionRuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNodeV1beta1CollectionRuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listNodeV1beta1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listNodeV1beta1RuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createNodeV1beta1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createNodeV1beta1RuntimeClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.handler);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deleteNodeV1beta1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteNodeV1beta1RuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(7, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readNodeV1beta1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readNodeV1beta1RuntimeClass('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.handler);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#patchNodeV1beta1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchNodeV1beta1RuntimeClass('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.handler);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#replaceNodeV1beta1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceNodeV1beta1RuntimeClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.handler);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchNodeV1beta1RuntimeClassList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNodeV1beta1RuntimeClassList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchNodeV1beta1RuntimeClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchNodeV1beta1RuntimeClass((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getPolicyAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getPolicyAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getPolicyV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getPolicyV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listPolicyV1beta1NamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listPolicyV1beta1NamespacedPodDisruptionBudget('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createPolicyV1beta1NamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createPolicyV1beta1NamespacedPodDisruptionBudget('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deletePolicyV1beta1NamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deletePolicyV1beta1NamespacedPodDisruptionBudget('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readPolicyV1beta1NamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readPolicyV1beta1NamespacedPodDisruptionBudget('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchPolicyV1beta1NamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchPolicyV1beta1NamespacedPodDisruptionBudget('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replacePolicyV1beta1NamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replacePolicyV1beta1NamespacedPodDisruptionBudget('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readPolicyV1beta1NamespacedPodDisruptionBudgetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readPolicyV1beta1NamespacedPodDisruptionBudgetStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#listPolicyV1beta1PodDisruptionBudgetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listPolicyV1beta1PodDisruptionBudgetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#deletePolicyV1beta1CollectionPodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deletePolicyV1beta1CollectionPodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(8, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listPolicyV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listPolicyV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createPolicyV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createPolicyV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deletePolicyV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deletePolicyV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readPolicyV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readPolicyV1beta1PodSecurityPolicy('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchPolicyV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchPolicyV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replacePolicyV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replacePolicyV1beta1PodSecurityPolicy('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#watchPolicyV1beta1NamespacedPodDisruptionBudgetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchPolicyV1beta1NamespacedPodDisruptionBudgetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchPolicyV1beta1NamespacedPodDisruptionBudget - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchPolicyV1beta1NamespacedPodDisruptionBudget((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchPolicyV1beta1PodSecurityPolicyList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchPolicyV1beta1PodSecurityPolicyList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchPolicyV1beta1PodSecurityPolicy - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchPolicyV1beta1PodSecurityPolicy((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getRbacAuthorizationAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getRbacAuthorizationAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getRbacAuthorizationV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getRbacAuthorizationV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteRbacAuthorizationV1CollectionClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1CollectionClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1ClusterRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#patchRbacAuthorizationV1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#replaceRbacAuthorizationV1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1CollectionClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1CollectionClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1ClusterRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1ClusterRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#patchRbacAuthorizationV1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#replaceRbacAuthorizationV1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1ClusterRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1CollectionNamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1CollectionNamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1NamespacedRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#patchRbacAuthorizationV1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#replaceRbacAuthorizationV1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1CollectionNamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1CollectionNamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1NamespacedRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1NamespacedRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#patchRbacAuthorizationV1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#replaceRbacAuthorizationV1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1NamespacedRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#listRbacAuthorizationV1RoleBindingForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1RoleBindingForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listRbacAuthorizationV1RoleForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1RoleForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchRbacAuthorizationV1ClusterRoleBindingList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1ClusterRoleBindingList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1ClusterRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1ClusterRoleList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1ClusterRoleList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1ClusterRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1NamespacedRoleBindingList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1NamespacedRoleBindingList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1NamespacedRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1NamespacedRoleList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1NamespacedRoleList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1NamespacedRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1RoleBindingListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1RoleBindingListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1RoleListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1RoleListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getRbacAuthorizationV1alpha1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getRbacAuthorizationV1alpha1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1alpha1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1alpha1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1alpha1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1alpha1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1alpha1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1alpha1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1alpha1ClusterRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#patchRbacAuthorizationV1alpha1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1alpha1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#replaceRbacAuthorizationV1alpha1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1alpha1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1alpha1CollectionClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1CollectionClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1alpha1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1alpha1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1alpha1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1alpha1ClusterRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1alpha1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1alpha1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1alpha1ClusterRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#patchRbacAuthorizationV1alpha1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1alpha1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#replaceRbacAuthorizationV1alpha1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1alpha1ClusterRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1alpha1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1alpha1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1alpha1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1alpha1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1alpha1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1alpha1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1alpha1NamespacedRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#patchRbacAuthorizationV1alpha1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1alpha1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#replaceRbacAuthorizationV1alpha1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1alpha1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1alpha1CollectionNamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1CollectionNamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1alpha1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1alpha1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1alpha1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1alpha1NamespacedRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1alpha1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1alpha1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1alpha1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1alpha1NamespacedRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#patchRbacAuthorizationV1alpha1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1alpha1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#replaceRbacAuthorizationV1alpha1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1alpha1NamespacedRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listRbacAuthorizationV1alpha1RoleForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1alpha1RoleForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchRbacAuthorizationV1alpha1ClusterRoleBindingList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1ClusterRoleBindingList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1ClusterRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1ClusterRoleList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1ClusterRoleList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1ClusterRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1NamespacedRoleBindingList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1NamespacedRoleBindingList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1NamespacedRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1NamespacedRoleList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1NamespacedRoleList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1NamespacedRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1alpha1RoleListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1alpha1RoleListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getRbacAuthorizationV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getRbacAuthorizationV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1beta1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1beta1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1beta1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1beta1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1beta1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1beta1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1beta1ClusterRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#patchRbacAuthorizationV1beta1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1beta1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#replaceRbacAuthorizationV1beta1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1beta1ClusterRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1beta1CollectionClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1CollectionClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1beta1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1beta1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1beta1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1beta1ClusterRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1beta1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1beta1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1beta1ClusterRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#patchRbacAuthorizationV1beta1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1beta1ClusterRole('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#replaceRbacAuthorizationV1beta1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1beta1ClusterRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.aggregationRule);
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1beta1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1beta1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1beta1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1beta1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1beta1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1beta1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1beta1NamespacedRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#patchRbacAuthorizationV1beta1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1beta1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#replaceRbacAuthorizationV1beta1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1beta1NamespacedRoleBinding('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.roleRef);
assert.equal(true, Array.isArray(data.response.subjects));
} 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('#deleteRbacAuthorizationV1beta1CollectionNamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1CollectionNamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listRbacAuthorizationV1beta1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1beta1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createRbacAuthorizationV1beta1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createRbacAuthorizationV1beta1NamespacedRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#deleteRbacAuthorizationV1beta1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteRbacAuthorizationV1beta1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readRbacAuthorizationV1beta1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readRbacAuthorizationV1beta1NamespacedRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#patchRbacAuthorizationV1beta1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchRbacAuthorizationV1beta1NamespacedRole('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#replaceRbacAuthorizationV1beta1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceRbacAuthorizationV1beta1NamespacedRole('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.rules));
} 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('#listRbacAuthorizationV1beta1RoleBindingForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1beta1RoleBindingForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#listRbacAuthorizationV1beta1RoleForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listRbacAuthorizationV1beta1RoleForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchRbacAuthorizationV1beta1ClusterRoleBindingList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1ClusterRoleBindingList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1ClusterRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1ClusterRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1ClusterRoleList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1ClusterRoleList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1ClusterRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1ClusterRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1NamespacedRoleBindingList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1NamespacedRoleBindingList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1NamespacedRoleBinding - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1NamespacedRoleBinding((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1NamespacedRoleList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1NamespacedRoleList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1NamespacedRole - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1NamespacedRole((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchRbacAuthorizationV1beta1RoleListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchRbacAuthorizationV1beta1RoleListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getSchedulingAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getSchedulingAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getSchedulingV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getSchedulingV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteSchedulingV1CollectionPriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSchedulingV1CollectionPriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listSchedulingV1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listSchedulingV1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createSchedulingV1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createSchedulingV1PriorityClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(false, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(5, data.response.value);
} 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('#deleteSchedulingV1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSchedulingV1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readSchedulingV1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readSchedulingV1PriorityClass('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(false, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(6, data.response.value);
} 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('#patchSchedulingV1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchSchedulingV1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(false, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(7, data.response.value);
} 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('#replaceSchedulingV1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceSchedulingV1PriorityClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(true, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(6, data.response.value);
} 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('#watchSchedulingV1PriorityClassList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSchedulingV1PriorityClassList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchSchedulingV1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSchedulingV1PriorityClass((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getSchedulingV1alpha1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getSchedulingV1alpha1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteSchedulingV1alpha1CollectionPriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSchedulingV1alpha1CollectionPriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listSchedulingV1alpha1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listSchedulingV1alpha1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createSchedulingV1alpha1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createSchedulingV1alpha1PriorityClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(true, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(8, data.response.value);
} 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('#deleteSchedulingV1alpha1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSchedulingV1alpha1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readSchedulingV1alpha1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readSchedulingV1alpha1PriorityClass('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(false, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(10, data.response.value);
} 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('#patchSchedulingV1alpha1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchSchedulingV1alpha1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(true, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(7, data.response.value);
} 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('#replaceSchedulingV1alpha1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceSchedulingV1alpha1PriorityClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(true, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(9, data.response.value);
} 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('#watchSchedulingV1alpha1PriorityClassList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSchedulingV1alpha1PriorityClassList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchSchedulingV1alpha1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSchedulingV1alpha1PriorityClass((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getSchedulingV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getSchedulingV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteSchedulingV1beta1CollectionPriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSchedulingV1beta1CollectionPriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listSchedulingV1beta1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listSchedulingV1beta1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createSchedulingV1beta1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createSchedulingV1beta1PriorityClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(false, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(1, data.response.value);
} 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('#deleteSchedulingV1beta1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSchedulingV1beta1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readSchedulingV1beta1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readSchedulingV1beta1PriorityClass('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(false, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(4, data.response.value);
} 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('#patchSchedulingV1beta1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchSchedulingV1beta1PriorityClass('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(false, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(5, data.response.value);
} 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('#replaceSchedulingV1beta1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceSchedulingV1beta1PriorityClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.description);
assert.equal(true, data.response.globalDefault);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(6, data.response.value);
} 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('#watchSchedulingV1beta1PriorityClassList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSchedulingV1beta1PriorityClassList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchSchedulingV1beta1PriorityClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSchedulingV1beta1PriorityClass((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getSettingsAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getSettingsAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getSettingsV1alpha1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getSettingsV1alpha1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteSettingsV1alpha1CollectionNamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSettingsV1alpha1CollectionNamespacedPodPreset('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listSettingsV1alpha1NamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listSettingsV1alpha1NamespacedPodPreset('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createSettingsV1alpha1NamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createSettingsV1alpha1NamespacedPodPreset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteSettingsV1alpha1NamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteSettingsV1alpha1NamespacedPodPreset('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(5, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readSettingsV1alpha1NamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readSettingsV1alpha1NamespacedPodPreset('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchSettingsV1alpha1NamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchSettingsV1alpha1NamespacedPodPreset('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceSettingsV1alpha1NamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceSettingsV1alpha1NamespacedPodPreset('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#listSettingsV1alpha1PodPresetForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listSettingsV1alpha1PodPresetForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#watchSettingsV1alpha1NamespacedPodPresetList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSettingsV1alpha1NamespacedPodPresetList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchSettingsV1alpha1NamespacedPodPreset - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSettingsV1alpha1NamespacedPodPreset((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchSettingsV1alpha1PodPresetListForAllNamespaces - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchSettingsV1alpha1PodPresetListForAllNamespaces((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getStorageAPIGroup - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getStorageAPIGroup((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.name);
assert.equal('object', typeof data.response.preferredVersion);
assert.equal(true, Array.isArray(data.response.serverAddressByClientCIDRs));
assert.equal(true, Array.isArray(data.response.versions));
} 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('#getStorageV1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getStorageV1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteStorageV1CollectionStorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1CollectionStorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listStorageV1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listStorageV1StorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createStorageV1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createStorageV1StorageClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(false, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#deleteStorageV1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1StorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readStorageV1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1StorageClass('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(true, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#patchStorageV1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1StorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(true, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#replaceStorageV1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1StorageClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(true, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#deleteStorageV1CollectionVolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1CollectionVolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listStorageV1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listStorageV1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createStorageV1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createStorageV1VolumeAttachment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteStorageV1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(1, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readStorageV1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1VolumeAttachment('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchStorageV1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceStorageV1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1VolumeAttachment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#readStorageV1VolumeAttachmentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1VolumeAttachmentStatus((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchStorageV1VolumeAttachmentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1VolumeAttachmentStatus('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceStorageV1VolumeAttachmentStatus - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1VolumeAttachmentStatus('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchStorageV1StorageClassList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1StorageClassList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1StorageClass((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1VolumeAttachmentList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1VolumeAttachmentList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1VolumeAttachment((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getStorageV1alpha1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getStorageV1alpha1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteStorageV1alpha1CollectionVolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1alpha1CollectionVolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listStorageV1alpha1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listStorageV1alpha1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createStorageV1alpha1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createStorageV1alpha1VolumeAttachment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteStorageV1alpha1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1alpha1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readStorageV1alpha1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1alpha1VolumeAttachment('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchStorageV1alpha1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1alpha1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceStorageV1alpha1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1alpha1VolumeAttachment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchStorageV1alpha1VolumeAttachmentList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1alpha1VolumeAttachmentList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1alpha1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1alpha1VolumeAttachment((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#getStorageV1beta1APIResources - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getStorageV1beta1APIResources((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.groupVersion);
assert.equal('string', data.response.kind);
assert.equal(true, Array.isArray(data.response.resources));
} 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('#deleteStorageV1beta1CollectionCSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1CollectionCSIDriver('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listStorageV1beta1CSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listStorageV1beta1CSIDriver('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createStorageV1beta1CSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createStorageV1beta1CSIDriver('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteStorageV1beta1CSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1CSIDriver('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(9, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readStorageV1beta1CSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1beta1CSIDriver('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchStorageV1beta1CSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1beta1CSIDriver('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceStorageV1beta1CSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1beta1CSIDriver('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteStorageV1beta1CollectionCSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1CollectionCSINode('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listStorageV1beta1CSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listStorageV1beta1CSINode('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createStorageV1beta1CSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createStorageV1beta1CSINode('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteStorageV1beta1CSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1CSINode('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(4, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readStorageV1beta1CSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1beta1CSINode('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#patchStorageV1beta1CSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1beta1CSINode('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#replaceStorageV1beta1CSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1beta1CSINode('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
} 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('#deleteStorageV1beta1CollectionStorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1CollectionStorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(10, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listStorageV1beta1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listStorageV1beta1StorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createStorageV1beta1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createStorageV1beta1StorageClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(true, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#deleteStorageV1beta1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1StorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(6, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readStorageV1beta1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1beta1StorageClass('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(true, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#patchStorageV1beta1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1beta1StorageClass('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(true, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#replaceStorageV1beta1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1beta1StorageClass('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal(true, data.response.allowVolumeExpansion);
assert.equal(true, Array.isArray(data.response.allowedTopologies));
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal(true, Array.isArray(data.response.mountOptions));
assert.equal('object', typeof data.response.parameters);
assert.equal('string', data.response.provisioner);
assert.equal('string', data.response.reclaimPolicy);
assert.equal('string', data.response.volumeBindingMode);
} 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('#deleteStorageV1beta1CollectionVolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1CollectionVolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(3, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#listStorageV1beta1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.listStorageV1beta1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(true, Array.isArray(data.response.items));
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
} 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('#createStorageV1beta1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.createStorageV1beta1VolumeAttachment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#deleteStorageV1beta1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.deleteStorageV1beta1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal(2, data.response.code);
assert.equal('object', typeof data.response.details);
assert.equal('string', data.response.kind);
assert.equal('string', data.response.message);
assert.equal('object', typeof data.response.metadata);
assert.equal('string', data.response.reason);
assert.equal('string', data.response.status);
} 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('#readStorageV1beta1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.readStorageV1beta1VolumeAttachment('fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#patchStorageV1beta1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.patchStorageV1beta1VolumeAttachment('fakedata', 'fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#replaceStorageV1beta1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.replaceStorageV1beta1VolumeAttachment('fakedata', 'fakedata', 'fakedata', (data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.apiVersion);
assert.equal('string', data.response.kind);
assert.equal('object', typeof data.response.metadata);
assert.equal('object', typeof data.response.spec);
assert.equal('object', typeof data.response.status);
} 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('#watchStorageV1beta1CSIDriverList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1CSIDriverList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1beta1CSIDriver - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1CSIDriver((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1beta1CSINodeList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1CSINodeList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1beta1CSINode - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1CSINode((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1beta1StorageClassList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1StorageClassList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1beta1StorageClass - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1StorageClass((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1beta1VolumeAttachmentList - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1VolumeAttachmentList((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#watchStorageV1beta1VolumeAttachment - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.watchStorageV1beta1VolumeAttachment((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('object', typeof data.response.object);
assert.equal('string', data.response.type);
} 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('#logFileListHandler - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.logFileListHandler((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#logFileHandler - errors', () => {
it('should work if integrated but since no mockdata should error when run standalone', (done) => {
try {
a.logFileHandler((data, error) => {
try {
if (stub) {
const displayE = 'Error 400 received on request';
runErrorAsserts(data, error, 'AD.500', 'Test-kubernetes-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('#getCodeVersion - errors', () => {
it('should work if integrated or standalone with mockdata', (done) => {
try {
a.getCodeVersion((data, error) => {
try {
runCommonAsserts(data, error);
if (stub) {
assert.equal('string', data.response.buildDate);
assert.equal('string', data.response.compiler);
assert.equal('string', data.response.gitCommit);
assert.equal('string', data.response.gitTreeState);
assert.equal('string', data.response.gitVersion);
assert.equal('string', data.response.goVersion);
assert.equal('string', data.response.major);
assert.equal('string', data.response.minor);
assert.equal('string', data.response.platform);
} 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);
});
});
});