balena-supervisor/test/15-ports.spec.ts
Cameron Diver 9e0c99e797 tests: Clean up and consistify naming scheme
Change-type: patch
Signed-off-by: Cameron Diver <cameron@balena.io>
2020-10-12 14:41:21 +01:00

399 lines
10 KiB
TypeScript

import { PortMap, PortRange } from '../src/compose/ports';
import { expect } from './lib/chai-config';
// Force cast `PortMap` as a public version so we can test it
const PortMapPublic = (PortMap as any) as new (
portStrOrObj: string | PortRange,
) => PortMap;
describe('Ports', function () {
describe('Port string parsing', function () {
it('should correctly parse a port string without a range', function () {
expect(new PortMapPublic('80')).to.deep.equal(
new PortMapPublic({
internalStart: 80,
internalEnd: 80,
externalStart: 80,
externalEnd: 80,
protocol: 'tcp',
host: '',
}),
);
expect(new PortMapPublic('80:80')).to.deep.equal(
new PortMapPublic({
internalStart: 80,
internalEnd: 80,
externalStart: 80,
externalEnd: 80,
protocol: 'tcp',
host: '',
}),
);
});
it('should correctly parse a port string without an external range', () =>
expect(new PortMapPublic('80-90')).to.deep.equal(
new PortMapPublic({
internalStart: 80,
internalEnd: 90,
externalStart: 80,
externalEnd: 90,
protocol: 'tcp',
host: '',
}),
));
it('should correctly parse a port string with a range', () =>
expect(new PortMapPublic('80-100:100-120')).to.deep.equal(
new PortMapPublic({
internalStart: 100,
internalEnd: 120,
externalStart: 80,
externalEnd: 100,
protocol: 'tcp',
host: '',
}),
));
it('should correctly parse a protocol', function () {
expect(new PortMapPublic('80/udp')).to.deep.equal(
new PortMapPublic({
internalStart: 80,
internalEnd: 80,
externalStart: 80,
externalEnd: 80,
protocol: 'udp',
host: '',
}),
);
expect(new PortMapPublic('80:80/udp')).to.deep.equal(
new PortMapPublic({
internalStart: 80,
internalEnd: 80,
externalStart: 80,
externalEnd: 80,
protocol: 'udp',
host: '',
}),
);
expect(new PortMapPublic('80-90:100-110/udp')).to.deep.equal(
new PortMapPublic({
internalStart: 100,
internalEnd: 110,
externalStart: 80,
externalEnd: 90,
protocol: 'udp',
host: '',
}),
);
});
it('should throw when the port string is incorrect', () =>
expect(() => new PortMapPublic('80-90:80-85')).to.throw);
});
describe('toDockerOpts', function () {
it('should correctly generate docker options', () =>
expect(new PortMapPublic('80').toDockerOpts()).to.deep.equal({
exposedPorts: {
'80/tcp': {},
},
portBindings: {
'80/tcp': [{ HostIp: '', HostPort: '80' }],
},
}));
it('should correctly generate docker options for a port range', () =>
expect(new PortMapPublic('80-85').toDockerOpts()).to.deep.equal({
exposedPorts: {
'80/tcp': {},
'81/tcp': {},
'82/tcp': {},
'83/tcp': {},
'84/tcp': {},
'85/tcp': {},
},
portBindings: {
'80/tcp': [{ HostIp: '', HostPort: '80' }],
'81/tcp': [{ HostIp: '', HostPort: '81' }],
'82/tcp': [{ HostIp: '', HostPort: '82' }],
'83/tcp': [{ HostIp: '', HostPort: '83' }],
'84/tcp': [{ HostIp: '', HostPort: '84' }],
'85/tcp': [{ HostIp: '', HostPort: '85' }],
},
}));
});
describe('fromDockerOpts', function () {
it('should correctly detect a port range', () =>
expect(
PortMap.fromDockerOpts({
'100/tcp': [{ HostIp: '123', HostPort: '200' }],
'101/tcp': [{ HostIp: '123', HostPort: '201' }],
'102/tcp': [{ HostIp: '123', HostPort: '202' }],
}),
).to.deep.equal([
new PortMapPublic({
internalStart: 100,
internalEnd: 102,
externalStart: 200,
externalEnd: 202,
protocol: 'tcp',
host: '123',
}),
]));
it('should correctly split ports into ranges', () =>
expect(
PortMap.fromDockerOpts({
'100/tcp': [{ HostIp: '123', HostPort: '200' }],
'101/tcp': [{ HostIp: '123', HostPort: '201' }],
'105/tcp': [{ HostIp: '123', HostPort: '205' }],
'106/tcp': [{ HostIp: '123', HostPort: '206' }],
'110/tcp': [{ HostIp: '123', HostPort: '210' }],
}),
).to.deep.equal([
new PortMapPublic({
internalStart: 100,
internalEnd: 101,
externalStart: 200,
externalEnd: 201,
protocol: 'tcp',
host: '123',
}),
new PortMapPublic({
internalStart: 105,
internalEnd: 106,
externalStart: 205,
externalEnd: 206,
protocol: 'tcp',
host: '123',
}),
new PortMapPublic({
internalStart: 110,
internalEnd: 110,
externalStart: 210,
externalEnd: 210,
protocol: 'tcp',
host: '123',
}),
]));
it('should correctly consider internal and external ports', () =>
expect(
PortMap.fromDockerOpts({
'100/tcp': [{ HostIp: '123', HostPort: '200' }],
'101/tcp': [{ HostIp: '123', HostPort: '101' }],
'102/tcp': [{ HostIp: '123', HostPort: '202' }],
}),
).to.deep.equal([
new PortMapPublic({
internalStart: 100,
internalEnd: 100,
externalStart: 200,
externalEnd: 200,
protocol: 'tcp',
host: '123',
}),
new PortMapPublic({
internalStart: 101,
internalEnd: 101,
externalStart: 101,
externalEnd: 101,
protocol: 'tcp',
host: '123',
}),
new PortMapPublic({
internalStart: 102,
internalEnd: 102,
externalStart: 202,
externalEnd: 202,
protocol: 'tcp',
host: '123',
}),
]));
it('should consider the host when generating ranges', () =>
expect(
PortMap.fromDockerOpts({
'100/tcp': [{ HostIp: '123', HostPort: '200' }],
'101/tcp': [{ HostIp: '456', HostPort: '201' }],
'102/tcp': [{ HostIp: '456', HostPort: '202' }],
}),
).to.deep.equal([
new PortMapPublic({
internalStart: 100,
internalEnd: 100,
externalStart: 200,
externalEnd: 200,
protocol: 'tcp',
host: '123',
}),
new PortMapPublic({
internalStart: 101,
internalEnd: 102,
externalStart: 201,
externalEnd: 202,
protocol: 'tcp',
host: '456',
}),
]));
it('should consider the protocol when generating ranges', () =>
expect(
PortMap.fromDockerOpts({
'100/tcp': [{ HostIp: '123', HostPort: '200' }],
'101/udp': [{ HostIp: '123', HostPort: '201' }],
'102/udp': [{ HostIp: '123', HostPort: '202' }],
}),
).to.deep.equal([
new PortMapPublic({
internalStart: 100,
internalEnd: 100,
externalStart: 200,
externalEnd: 200,
protocol: 'tcp',
host: '123',
}),
new PortMapPublic({
internalStart: 101,
internalEnd: 102,
externalStart: 201,
externalEnd: 202,
protocol: 'udp',
host: '123',
}),
]));
it('should correctly detect multiple hosts ports on an internal port', () =>
expect(
PortMap.fromDockerOpts({
'100/tcp': [
{ HostIp: '123', HostPort: '200' },
{ HostIp: '123', HostPort: '201' },
],
}),
).to.deep.equal([
new PortMapPublic({
internalStart: 100,
internalEnd: 100,
externalStart: 200,
externalEnd: 200,
protocol: 'tcp',
host: '123',
}),
new PortMapPublic({
internalStart: 100,
internalEnd: 100,
externalStart: 201,
externalEnd: 201,
protocol: 'tcp',
host: '123',
}),
]));
});
describe('Running container comparison', () =>
it('should not consider order when comparing current and target state', function () {
const portBindings = require('./data/ports/not-ascending/port-bindings.json');
const compose = require('./data/ports/not-ascending/compose.json');
const portMapsCurrent = PortMap.fromDockerOpts(portBindings);
const portMapsTarget = PortMap.fromComposePorts(compose.ports);
expect(portMapsTarget).to.deep.equal(portMapsCurrent);
}));
describe('fromComposePorts', () =>
it('should normalise compose ports', () =>
expect(
PortMap.fromComposePorts(['80:80', '81:81', '82:82']),
).to.deep.equal([new PortMapPublic('80-82')])));
describe('normalisePortMaps', function () {
it('should correctly normalise PortMap lists', function () {
expect(
PortMap.normalisePortMaps([
new PortMapPublic('80:90'),
new PortMapPublic('81:91'),
]),
).to.deep.equal([new PortMapPublic('80-81:90-91')]);
expect(
PortMap.normalisePortMaps([
new PortMapPublic('80:90'),
new PortMapPublic('81:91'),
new PortMapPublic('82:92'),
new PortMapPublic('83:93'),
new PortMapPublic('84:94'),
new PortMapPublic('85:95'),
new PortMapPublic('86:96'),
new PortMapPublic('87:97'),
new PortMapPublic('88:98'),
new PortMapPublic('89:99'),
new PortMapPublic('90:100'),
]),
).to.deep.equal([new PortMapPublic('80-90:90-100')]);
expect(PortMap.normalisePortMaps([])).to.deep.equal([]);
});
it('should correctly consider protocols', function () {
expect(
PortMap.normalisePortMaps([
new PortMapPublic('80:90'),
new PortMapPublic('81:91/udp'),
]),
).to.deep.equal([
new PortMapPublic('80:90'),
new PortMapPublic('81:91/udp'),
]);
expect(
PortMap.normalisePortMaps([
new PortMapPublic('80:90'),
new PortMapPublic('100:110/udp'),
new PortMapPublic('81:91'),
]),
).to.deep.equal([
new PortMapPublic('80-81:90-91'),
new PortMapPublic('100:110/udp'),
]);
// This shouldn't ever be provided, but it shows the algorithm
// working properly
expect(
PortMap.normalisePortMaps([
new PortMapPublic('80:90'),
new PortMapPublic('81:91/udp'),
new PortMapPublic('81:91'),
]),
).to.deep.equal([
new PortMapPublic('80-81:90-91'),
new PortMapPublic('81:91/udp'),
]);
});
it('should correctly consider hosts', function () {
expect(
PortMap.normalisePortMaps([
new PortMapPublic('127.0.0.1:80:80'),
new PortMapPublic('81:81'),
]),
).to.deep.equal([
new PortMapPublic('127.0.0.1:80:80'),
new PortMapPublic('81:81'),
]);
expect(
PortMap.normalisePortMaps([
new PortMapPublic('127.0.0.1:80:80'),
new PortMapPublic('127.0.0.1:81:81'),
]),
).to.deep.equal([new PortMapPublic('127.0.0.1:80-81:80-81')]);
});
});
});