balena-supervisor/test/legacy/10-api-binder.spec.ts

448 lines
14 KiB
TypeScript
Raw Normal View History

import { stripIndent } from 'common-tags';
import { promises as fs } from 'fs';
import { Server } from 'net';
import { SinonSpy, SinonStub, spy, stub } from 'sinon';
import { expect } from 'chai';
import prepare = require('~/test-lib/prepare');
import * as config from '~/src/config';
import * as deviceState from '~/src/device-state';
import Log from '~/lib/supervisor-console';
import balenaAPI = require('~/test-lib/mocked-balena-api');
import { schema } from '~/src/config/schema';
import ConfigJsonConfigBackend from '~/src/config/configJson';
import * as TargetState from '~/src/device-state/target-state';
import * as ApiHelper from '~/lib/api-helper';
import supervisorVersion = require('~/lib/supervisor-version');
import * as eventTracker from '~/src/event-tracker';
import { TypedError } from 'typed-error';
import { DeviceNotFoundError } from '~/lib/errors';
let ApiBinder: typeof import('~/src/api-binder');
class ExpectedError extends TypedError {}
const initModels = async (obj: Dictionary<any>, filename: string) => {
await prepare();
// @ts-expect-error setting read-only property
config.configJsonBackend = new ConfigJsonConfigBackend(schema, filename);
await config.generateRequiredFields();
// @ts-expect-error using private properties
config.configJsonBackend.cache = await config.configJsonBackend.read();
await config.generateRequiredFields();
obj.logger = {
clearOutOfDateDBLogs: () => {
/* noop */
},
} as any;
ApiBinder = await import('~/src/api-binder');
await ApiBinder.initialized();
obj.apiBinder = ApiBinder;
await deviceState.initialized();
obj.deviceState = deviceState;
};
const mockProvisioningOpts = {
apiEndpoint: 'http://0.0.0.0:3000',
uuid: 'abcd',
deviceApiKey: 'averyvalidkey',
provisioningApiKey: 'anotherveryvalidkey',
apiTimeout: 30000,
};
describe('ApiBinder', () => {
const defaultConfigBackend = config.configJsonBackend;
let server: Server;
before(async () => {
delete require.cache[require.resolve('~/src/api-binder')];
spy(balenaAPI.balenaBackend!, 'registerHandler');
server = balenaAPI.listen(3000);
});
after(() => {
// @ts-expect-error setting read-only property
balenaAPI.balenaBackend!.registerHandler.restore();
try {
server.close();
} catch (error) {
/* noop */
}
});
// We do not support older OS versions anymore, so we only test this case
describe('on an OS with deviceApiKey support', () => {
const components: Dictionary<any> = {};
let eventTrackSpy: SinonSpy;
before(async () => {
eventTrackSpy = spy(eventTracker, 'track');
await initModels(components, '/config-apibinder.json');
});
afterEach(() => {
eventTrackSpy.resetHistory();
});
after(async () => {
eventTrackSpy.restore();
// @ts-expect-error setting read-only property
config.configJsonBackend = defaultConfigBackend;
await config.generateRequiredFields();
});
it('provisions a device', async () => {
const opts = await config.get('provisioningOptions');
await ApiHelper.provision(components.apiBinder.balenaApi, opts);
expect(balenaAPI.balenaBackend!.registerHandler).to.be.calledOnce;
expect(eventTrackSpy).to.be.called;
expect(eventTrackSpy).to.be.calledWith('Device bootstrap success');
// @ts-expect-error function does not exist on type
balenaAPI.balenaBackend!.registerHandler.resetHistory();
});
it('exchanges keys if resource conflict when provisioning', async () => {
// Get current config to extend
const currentConfig = await config.get('provisioningOptions');
// Stub config values so we have correct conditions
const configStub = stub(config, 'get').resolves({
...currentConfig,
registered_at: null,
provisioningApiKey: '123', // Previous test case deleted the provisioningApiKey so add one
uuid: 'not-unique', // This UUID is used in mocked-balena-api as an existing registered UUID
});
// If api-binder reaches this function then tests pass
// We throw an error so we don't have to keep stubbing
const functionToReach = stub(
ApiHelper,
'exchangeKeyAndGetDeviceOrRegenerate',
).throws(new ExpectedError());
spy(Log, 'debug');
try {
const opts = await config.get('provisioningOptions');
await ApiHelper.provision(components.apiBinder.balenaApi, opts);
} catch (e) {
// Check that the error thrown is from this test
expect(e).to.be.instanceOf(ExpectedError);
}
expect(functionToReach.called).to.be.true;
expect((Log.debug as SinonSpy).lastCall.lastArg).to.equal(
'UUID already registered, trying a key exchange',
);
// Restore stubs
configStub.restore();
functionToReach.restore();
(Log.debug as SinonStub).restore();
});
it('deletes the provisioning key', async () => {
expect(await config.get('apiKey')).to.be.undefined;
});
it('sends the correct parameters when provisioning', async () => {
const conf = JSON.parse(
await fs.readFile('./test/data/config-apibinder.json', 'utf8'),
);
expect(balenaAPI.balenaBackend!.devices).to.deep.equal({
'1': {
id: 1,
application: conf.applicationId,
uuid: conf.uuid,
device_type: conf.deviceType,
api_key: conf.deviceApiKey,
mac_address: '00:11:22:33:44:55 66:77:88:99:AA:BB',
os_variant: 'dev',
os_version: 'balenaOS 2.0.6+rev1',
supervisor_version: supervisorVersion,
},
});
});
});
describe('fetchDevice', () => {
const components: Dictionary<any> = {};
before(() => {
return initModels(components, '/config-apibinder.json');
});
after(async () => {
// @ts-expect-error setting read-only property
config.configJsonBackend = defaultConfigBackend;
await config.generateRequiredFields();
});
it('gets a device by its uuid from the balena API', async () => {
// Manually add a device to the mocked API
balenaAPI.balenaBackend!.devices[3] = {
id: 3,
user: 'foo',
application: 1337,
uuid: 'abcd',
device_type: 'intel-nuc',
api_key: 'verysecure',
};
const device = await ApiHelper.fetchDevice(
components.apiBinder.balenaApi,
'abcd',
'someApiKey',
30000,
);
expect(device).to.deep.equal(balenaAPI.balenaBackend!.devices[3]);
});
});
describe('exchangeKeyAndGetDevice', () => {
const components: Dictionary<any> = {};
before(() => {
return initModels(components, '/config-apibinder.json');
});
after(async () => {
// @ts-expect-error setting read-only property
config.configJsonBackend = defaultConfigBackend;
await config.generateRequiredFields();
});
it('returns the device if it can fetch it with the deviceApiKey', async () => {
spy(balenaAPI.balenaBackend!, 'deviceKeyHandler');
const fetchDeviceStub = stub(ApiHelper, 'fetchDevice');
fetchDeviceStub.onCall(0).resolves({ id: 1 });
const device = await ApiHelper.exchangeKeyAndGetDevice(
components.apiBinder.balenaApi,
mockProvisioningOpts,
);
expect(balenaAPI.balenaBackend!.deviceKeyHandler).to.not.be.called;
expect(device).to.deep.equal({ id: 1 });
expect(fetchDeviceStub).to.be.calledOnce;
// @ts-expect-error function does not exist on type
balenaAPI.balenaBackend.deviceKeyHandler.restore();
fetchDeviceStub.restore();
});
it('throws if it cannot get the device with any of the keys', () => {
spy(balenaAPI.balenaBackend!, 'deviceKeyHandler');
const fetchDeviceStub = stub(ApiHelper, 'fetchDevice').throws(
new DeviceNotFoundError(),
);
const promise = ApiHelper.exchangeKeyAndGetDevice(
components.apiBinder.balenaApi,
mockProvisioningOpts,
);
promise.catch(() => {
/* noop */
});
return expect(promise).to.be.rejected.then(() => {
expect(balenaAPI.balenaBackend!.deviceKeyHandler).to.not.be.called;
expect(fetchDeviceStub).to.be.calledTwice;
fetchDeviceStub.restore();
// @ts-expect-error function does not exist on type
balenaAPI.balenaBackend.deviceKeyHandler.restore();
});
});
it('exchanges the key and returns the device if the provisioning key is valid', async () => {
spy(balenaAPI.balenaBackend!, 'deviceKeyHandler');
const fetchDeviceStub = stub(ApiHelper, 'fetchDevice');
fetchDeviceStub.onCall(0).throws(new DeviceNotFoundError());
fetchDeviceStub.onCall(1).returns(Promise.resolve({ id: 1 }));
const device = await ApiHelper.exchangeKeyAndGetDevice(
components.apiBinder.balenaApi,
mockProvisioningOpts as any,
);
expect(balenaAPI.balenaBackend!.deviceKeyHandler).to.be.calledOnce;
expect(device).to.deep.equal({ id: 1 });
expect(fetchDeviceStub).to.be.calledTwice;
fetchDeviceStub.restore();
// @ts-expect-error function does not exist on type
balenaAPI.balenaBackend.deviceKeyHandler.restore();
});
});
describe('unmanaged mode', () => {
const components: Dictionary<any> = {};
before(() => {
return initModels(components, '/config-apibinder-offline.json');
});
after(async () => {
// @ts-expect-error setting read-only property
config.configJsonBackend = defaultConfigBackend;
await config.generateRequiredFields();
});
it('does not generate a key if the device is in unmanaged mode', async () => {
const mode = await config.get('unmanaged');
// Ensure offline mode is set
expect(mode).to.equal(true);
// Check that there is no deviceApiKey
const conf = await config.getMany(['deviceApiKey', 'uuid']);
expect(conf['deviceApiKey']).to.be.empty;
expect(conf['uuid']).to.not.be.undefined;
});
describe('Minimal config unmanaged mode', () => {
const components2: Dictionary<any> = {};
before(() => {
return initModels(components2, '/config-apibinder-offline2.json');
});
it('does not generate a key with the minimal config', async () => {
const mode = await config.get('unmanaged');
expect(mode).to.equal(true);
const conf = await config.getMany(['deviceApiKey', 'uuid']);
expect(conf['deviceApiKey']).to.be.empty;
return expect(conf['uuid']).to.not.be.undefined;
});
});
});
describe('healthchecks', () => {
const components: Dictionary<any> = {};
let configStub: SinonStub;
let infoLobSpy: SinonSpy;
let previousLastFetch: ReturnType<typeof process.hrtime>;
before(async () => {
await initModels(components, '/config-apibinder.json');
previousLastFetch = TargetState.lastFetch;
});
after(async () => {
// @ts-expect-error setting read-only property
config.configJsonBackend = defaultConfigBackend;
await config.generateRequiredFields();
});
beforeEach(() => {
// This configStub will be modified in each test case so we can
// create the exact conditions we want to for testing healthchecks
configStub = stub(config, 'getMany');
infoLobSpy = spy(Log, 'info');
});
afterEach(() => {
configStub.restore();
infoLobSpy.restore();
(TargetState as any).lastFetch = previousLastFetch;
});
it('passes with correct conditions', async () => {
// Set unmanaged to false so we check all values
// The other values are stubbed to make it pass
configStub.resolves({
unmanaged: false,
appUpdatePollInterval: 1000,
connectivityCheckEnabled: false,
});
// Set lastFetch to now so it is within appUpdatePollInterval
(TargetState as any).lastFetch = process.hrtime();
expect(await components.apiBinder.healthcheck()).to.equal(true);
});
it('passes if unmanaged is true and exit early', async () => {
// Setup failing conditions
configStub.resolves({
unmanaged: false,
appUpdatePollInterval: null,
connectivityCheckEnabled: false,
});
// Verify this causes healthcheck to fail
expect(await components.apiBinder.healthcheck()).to.equal(false);
// Do it again but set unmanaged to true
configStub.resolves({
unmanaged: true,
appUpdatePollInterval: null,
connectivityCheckEnabled: false,
});
expect(await components.apiBinder.healthcheck()).to.equal(true);
});
it('fails if appUpdatePollInterval not set in config and exit early', async () => {
configStub.resolves({
unmanaged: false,
appUpdatePollInterval: null,
connectivityCheckEnabled: false,
});
expect(await components.apiBinder.healthcheck()).to.equal(false);
expect(Log.info).to.be.calledOnce;
expect((Log.info as SinonSpy).lastCall?.lastArg).to.equal(
'Healthcheck failure - Config value `appUpdatePollInterval` cannot be null',
);
});
it("fails when hasn't checked target state within poll interval", async () => {
configStub.resolves({
unmanaged: false,
appUpdatePollInterval: 1,
connectivityCheckEnabled: false,
});
expect(await components.apiBinder.healthcheck()).to.equal(false);
expect(Log.info).to.be.calledOnce;
expect((Log.info as SinonSpy).lastCall?.lastArg).to.equal(
'Healthcheck failure - Device has not fetched target state within appUpdatePollInterval limit',
);
});
it('fails when stateReportHealthy is false', async () => {
const currentState = await import('~/src/api-binder/report');
configStub.resolves({
unmanaged: false,
appUpdatePollInterval: 1000,
connectivityCheckEnabled: true,
});
// Set lastFetch to now so it is within appUpdatePollInterval
(TargetState as any).lastFetch = process.hrtime();
// Copy previous values to restore later
const previousStateReportErrors = currentState.stateReportErrors;
const previousDeviceStateConnected =
// @ts-ignore
components.deviceState.connected;
// Set additional conditions not in configStub to cause a fail
try {
currentState.stateReportErrors = 4;
components.deviceState.connected = true;
expect(await components.apiBinder.healthcheck()).to.equal(false);
expect(Log.info).to.be.calledOnce;
expect((Log.info as SinonSpy).lastCall?.lastArg).to.equal(
stripIndent`
Healthcheck failure - At least ONE of the following conditions must be true:
- No connectivityCheckEnabled ? false
- device state is disconnected ? false
- stateReportErrors less then 3 ? false`,
);
} finally {
// Restore previous values
currentState.stateReportErrors = previousStateReportErrors;
components.deviceState.connected = previousDeviceStateConnected;
}
});
});
});