462c6653ac
* Allow running jobs from a namespace-limited token * qpNamespace cleanup * Looks like parse can deal with a * namespace * A little diff cleanup * Defensive destructuring * Removing accidental friendly-fire on can-scale * Testfix: Job run buttons from jobs index * Testfix: activeRegion job adapter string * Testfix: unit tests for job abilities correctly reflect the any-namespace rule * Testfix: job editor test looks for requests with namespace applied on plan
617 lines
19 KiB
JavaScript
617 lines
19 KiB
JavaScript
import { next } from '@ember/runloop';
|
|
import { assign } from '@ember/polyfills';
|
|
import { settled } from '@ember/test-helpers';
|
|
import { setupTest } from 'ember-qunit';
|
|
import { module, test } from 'qunit';
|
|
import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
|
|
import { AbortController } from 'fetch';
|
|
import { TextEncoderLite } from 'text-encoder-lite';
|
|
import base64js from 'base64-js';
|
|
|
|
module('Unit | Adapter | Job', function (hooks) {
|
|
setupTest(hooks);
|
|
|
|
hooks.beforeEach(async function () {
|
|
this.store = this.owner.lookup('service:store');
|
|
this.subject = () => this.store.adapterFor('job');
|
|
|
|
window.sessionStorage.clear();
|
|
window.localStorage.clear();
|
|
|
|
this.server = startMirage();
|
|
|
|
this.initializeUI = async ({ region, namespace } = {}) => {
|
|
if (namespace) window.localStorage.nomadActiveNamespace = namespace;
|
|
if (region) window.localStorage.nomadActiveRegion = region;
|
|
|
|
this.server.create('namespace');
|
|
this.server.create('namespace', { id: 'some-namespace' });
|
|
this.server.create('node');
|
|
this.server.create('job', { id: 'job-1', namespaceId: 'default' });
|
|
this.server.create('job', { id: 'job-2', namespaceId: 'some-namespace' });
|
|
|
|
this.server.create('region', { id: 'region-1' });
|
|
this.server.create('region', { id: 'region-2' });
|
|
|
|
this.system = this.owner.lookup('service:system');
|
|
|
|
// Namespace, default region, and all regions are requests that all
|
|
// job requests depend on. Fetching them ahead of time means testing
|
|
// job adapter behavior in isolation.
|
|
await this.system.get('namespaces');
|
|
this.system.get('shouldIncludeRegion');
|
|
await this.system.get('defaultRegion');
|
|
|
|
// Reset the handledRequests array to avoid accounting for this
|
|
// namespaces request everywhere.
|
|
this.server.pretender.handledRequests.length = 0;
|
|
};
|
|
|
|
this.initializeWithJob = async (props = {}) => {
|
|
await this.initializeUI(props);
|
|
|
|
const job = await this.store.findRecord(
|
|
'job',
|
|
JSON.stringify(['job-1', props.namespace || 'default'])
|
|
);
|
|
this.server.pretender.handledRequests.length = 0;
|
|
return job;
|
|
};
|
|
});
|
|
|
|
hooks.afterEach(function () {
|
|
this.server.shutdown();
|
|
});
|
|
|
|
test('The job endpoint is the only required endpoint for fetching a job', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const jobName = 'job-1';
|
|
const jobNamespace = 'default';
|
|
const jobId = JSON.stringify([jobName, jobNamespace]);
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
|
|
await settled();
|
|
assert.deepEqual(
|
|
pretender.handledRequests.mapBy('url'),
|
|
[`/v1/job/${jobName}`],
|
|
'The only request made is /job/:id'
|
|
);
|
|
});
|
|
|
|
test('When a namespace is set in localStorage but a job in the default namespace is requested, the namespace query param is not present', async function (assert) {
|
|
await this.initializeUI({ namespace: 'some-namespace' });
|
|
|
|
const { pretender } = this.server;
|
|
const jobName = 'job-1';
|
|
const jobNamespace = 'default';
|
|
const jobId = JSON.stringify([jobName, jobNamespace]);
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
await settled();
|
|
|
|
assert.deepEqual(
|
|
pretender.handledRequests.mapBy('url'),
|
|
[`/v1/job/${jobName}`],
|
|
'The only request made is /job/:id with no namespace query param'
|
|
);
|
|
});
|
|
|
|
test('When a namespace is in localStorage and the requested job is in the default namespace, the namespace query param is left out', async function (assert) {
|
|
await this.initializeUI({ namespace: 'red-herring' });
|
|
|
|
const { pretender } = this.server;
|
|
const jobName = 'job-1';
|
|
const jobNamespace = 'default';
|
|
const jobId = JSON.stringify([jobName, jobNamespace]);
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
await settled();
|
|
|
|
assert.deepEqual(
|
|
pretender.handledRequests.mapBy('url'),
|
|
[`/v1/job/${jobName}`],
|
|
'The request made is /job/:id with no namespace query param'
|
|
);
|
|
});
|
|
|
|
test('When the job has a namespace other than default, it is in the URL', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const jobName = 'job-2';
|
|
const jobNamespace = 'some-namespace';
|
|
const jobId = JSON.stringify([jobName, jobNamespace]);
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
await settled();
|
|
|
|
assert.deepEqual(
|
|
pretender.handledRequests.mapBy('url'),
|
|
[`/v1/job/${jobName}?namespace=${jobNamespace}`],
|
|
'The only request made is /job/:id?namespace=:namespace'
|
|
);
|
|
});
|
|
|
|
test('When there is no token set in the token service, no X-Nomad-Token header is set', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const jobId = JSON.stringify(['job-1', 'default']);
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
await settled();
|
|
|
|
assert.notOk(
|
|
pretender.handledRequests
|
|
.mapBy('requestHeaders')
|
|
.some((headers) => headers['X-Nomad-Token']),
|
|
'No token header present on either job request'
|
|
);
|
|
});
|
|
|
|
test('When a token is set in the token service, then X-Nomad-Token header is set', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const jobId = JSON.stringify(['job-1', 'default']);
|
|
const secret = 'here is the secret';
|
|
|
|
this.subject().set('token.secret', secret);
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
await settled();
|
|
|
|
assert.ok(
|
|
pretender.handledRequests
|
|
.mapBy('requestHeaders')
|
|
.every((headers) => headers['X-Nomad-Token'] === secret),
|
|
'The token header is present on both job requests'
|
|
);
|
|
});
|
|
|
|
test('findAll can be watched', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
|
|
const request = () =>
|
|
this.subject().findAll(null, { modelName: 'job' }, null, {
|
|
reload: true,
|
|
adapterOptions: { watch: true },
|
|
});
|
|
|
|
request();
|
|
assert.equal(
|
|
pretender.handledRequests[0].url,
|
|
'/v1/jobs?index=1',
|
|
'Second request is a blocking request for jobs'
|
|
);
|
|
|
|
await settled();
|
|
request();
|
|
assert.equal(
|
|
pretender.handledRequests[1].url,
|
|
'/v1/jobs?index=2',
|
|
'Third request is a blocking request with an incremented index param'
|
|
);
|
|
|
|
await settled();
|
|
});
|
|
|
|
test('findRecord can be watched', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const jobId = JSON.stringify(['job-1', 'default']);
|
|
const { pretender } = this.server;
|
|
|
|
const request = () =>
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId, {
|
|
reload: true,
|
|
adapterOptions: { watch: true },
|
|
});
|
|
|
|
request();
|
|
assert.equal(
|
|
pretender.handledRequests[0].url,
|
|
'/v1/job/job-1?index=1',
|
|
'Second request is a blocking request for job-1'
|
|
);
|
|
|
|
await settled();
|
|
request();
|
|
assert.equal(
|
|
pretender.handledRequests[1].url,
|
|
'/v1/job/job-1?index=2',
|
|
'Third request is a blocking request with an incremented index param'
|
|
);
|
|
|
|
await settled();
|
|
});
|
|
|
|
test('relationships can be reloaded', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const plainId = 'job-1';
|
|
const mockModel = makeMockModel(plainId);
|
|
|
|
this.subject().reloadRelationship(mockModel, 'summary');
|
|
await settled();
|
|
assert.equal(
|
|
pretender.handledRequests[0].url,
|
|
`/v1/job/${plainId}/summary`,
|
|
'Relationship was reloaded'
|
|
);
|
|
});
|
|
|
|
test('relationship reloads can be watched', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const plainId = 'job-1';
|
|
const mockModel = makeMockModel(plainId);
|
|
|
|
this.subject().reloadRelationship(mockModel, 'summary', { watch: true });
|
|
assert.equal(
|
|
pretender.handledRequests[0].url,
|
|
'/v1/job/job-1/summary?index=1',
|
|
'First request is a blocking request for job-1 summary relationship'
|
|
);
|
|
|
|
await settled();
|
|
this.subject().reloadRelationship(mockModel, 'summary', { watch: true });
|
|
await settled();
|
|
|
|
assert.equal(
|
|
pretender.handledRequests[1].url,
|
|
'/v1/job/job-1/summary?index=2',
|
|
'Second request is a blocking request with an incremented index param'
|
|
);
|
|
});
|
|
|
|
test('findAll can be canceled', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const controller = new AbortController();
|
|
|
|
pretender.get('/v1/jobs', () => [200, {}, '[]'], true);
|
|
|
|
this.subject()
|
|
.findAll(null, { modelName: 'job' }, null, {
|
|
reload: true,
|
|
adapterOptions: { watch: true, abortController: controller },
|
|
})
|
|
.catch(() => {});
|
|
|
|
const { request: xhr } = pretender.requestReferences[0];
|
|
assert.equal(xhr.status, 0, 'Request is still pending');
|
|
|
|
// Schedule the cancelation before waiting
|
|
next(() => {
|
|
controller.abort();
|
|
});
|
|
|
|
await settled();
|
|
assert.ok(xhr.aborted, 'Request was aborted');
|
|
});
|
|
|
|
test('findRecord can be canceled', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const jobId = JSON.stringify(['job-1', 'default']);
|
|
const controller = new AbortController();
|
|
|
|
pretender.get('/v1/job/:id', () => [200, {}, '{}'], true);
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId, {
|
|
reload: true,
|
|
adapterOptions: { watch: true, abortController: controller },
|
|
});
|
|
|
|
const { request: xhr } = pretender.requestReferences[0];
|
|
assert.equal(xhr.status, 0, 'Request is still pending');
|
|
|
|
// Schedule the cancelation before waiting
|
|
next(() => {
|
|
controller.abort();
|
|
});
|
|
|
|
await settled();
|
|
assert.ok(xhr.aborted, 'Request was aborted');
|
|
});
|
|
|
|
test('relationship reloads can be canceled', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const plainId = 'job-1';
|
|
const controller = new AbortController();
|
|
const mockModel = makeMockModel(plainId);
|
|
pretender.get('/v1/job/:id/summary', () => [200, {}, '{}'], true);
|
|
|
|
this.subject().reloadRelationship(mockModel, 'summary', {
|
|
watch: true,
|
|
abortController: controller,
|
|
});
|
|
|
|
const { request: xhr } = pretender.requestReferences[0];
|
|
assert.equal(xhr.status, 0, 'Request is still pending');
|
|
|
|
// Schedule the cancelation before waiting
|
|
next(() => {
|
|
controller.abort();
|
|
});
|
|
|
|
await settled();
|
|
assert.ok(xhr.aborted, 'Request was aborted');
|
|
});
|
|
|
|
test('requests can be canceled even if multiple requests for the same URL were made', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const jobId = JSON.stringify(['job-1', 'default']);
|
|
const controller1 = new AbortController();
|
|
const controller2 = new AbortController();
|
|
|
|
pretender.get('/v1/job/:id', () => [200, {}, '{}'], true);
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId, {
|
|
reload: true,
|
|
adapterOptions: { watch: true, abortController: controller1 },
|
|
});
|
|
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId, {
|
|
reload: true,
|
|
adapterOptions: { watch: true, abortController: controller2 },
|
|
});
|
|
|
|
const { request: xhr } = pretender.requestReferences[0];
|
|
const { request: xhr2 } = pretender.requestReferences[1];
|
|
assert.equal(xhr.status, 0, 'Request is still pending');
|
|
assert.equal(
|
|
pretender.requestReferences.length,
|
|
2,
|
|
'Two findRecord requests were made'
|
|
);
|
|
assert.equal(
|
|
pretender.requestReferences.mapBy('url').uniq().length,
|
|
1,
|
|
'The two requests have the same URL'
|
|
);
|
|
|
|
// Schedule the cancelation and resolution before waiting
|
|
next(() => {
|
|
controller1.abort();
|
|
pretender.resolve(xhr2);
|
|
});
|
|
|
|
await settled();
|
|
assert.ok(xhr.aborted, 'Request one was aborted');
|
|
assert.notOk(xhr2.aborted, 'Request two was not aborted');
|
|
});
|
|
|
|
test('dispatch job encodes payload as base64', async function (assert) {
|
|
const job = await this.initializeWithJob();
|
|
job.set('parameterized', true);
|
|
|
|
const payload = "I'm a payload 🙂";
|
|
|
|
// Base64 encode payload.
|
|
const Encoder = new TextEncoderLite('utf-8');
|
|
const encodedPayload = base64js.fromByteArray(Encoder.encode(payload));
|
|
|
|
await this.subject().dispatch(job, {}, payload);
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/job/${job.plainId}/dispatch`);
|
|
assert.equal(request.method, 'POST');
|
|
assert.deepEqual(JSON.parse(request.requestBody), {
|
|
Payload: encodedPayload,
|
|
Meta: {},
|
|
});
|
|
});
|
|
|
|
test('when there is no region set, requests are made without the region query param', async function (assert) {
|
|
await this.initializeUI();
|
|
|
|
const { pretender } = this.server;
|
|
const jobName = 'job-1';
|
|
const jobNamespace = 'default';
|
|
const jobId = JSON.stringify([jobName, jobNamespace]);
|
|
|
|
await settled();
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
this.subject().findAll(null, { modelName: 'job' }, null);
|
|
await settled();
|
|
|
|
assert.deepEqual(
|
|
pretender.handledRequests.mapBy('url'),
|
|
[`/v1/job/${jobName}`, '/v1/jobs'],
|
|
'No requests include the region query param'
|
|
);
|
|
});
|
|
|
|
test('when there is a region set, requests are made with the region query param', async function (assert) {
|
|
const region = 'region-2';
|
|
|
|
await this.initializeUI({ region });
|
|
|
|
const { pretender } = this.server;
|
|
const jobName = 'job-1';
|
|
const jobNamespace = 'default';
|
|
const jobId = JSON.stringify([jobName, jobNamespace]);
|
|
|
|
await settled();
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
this.subject().findAll(null, { modelName: 'job' }, null);
|
|
await settled();
|
|
|
|
assert.deepEqual(
|
|
pretender.handledRequests.mapBy('url'),
|
|
[`/v1/job/${jobName}?region=${region}`, `/v1/jobs?region=${region}`],
|
|
'Requests include the region query param'
|
|
);
|
|
});
|
|
|
|
test('when the region is set to the default region, requests are made without the region query param', async function (assert) {
|
|
await this.initializeUI({ region: 'region-1' });
|
|
|
|
const { pretender } = this.server;
|
|
const jobName = 'job-1';
|
|
const jobNamespace = 'default';
|
|
const jobId = JSON.stringify([jobName, jobNamespace]);
|
|
|
|
await settled();
|
|
this.subject().findRecord(null, { modelName: 'job' }, jobId);
|
|
this.subject().findAll(null, { modelName: 'job' }, null);
|
|
await settled();
|
|
|
|
assert.deepEqual(
|
|
pretender.handledRequests.mapBy('url'),
|
|
[`/v1/job/${jobName}`, '/v1/jobs'],
|
|
'No requests include the region query param'
|
|
);
|
|
});
|
|
|
|
test('fetchRawDefinition requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
|
|
await this.subject().fetchRawDefinition(job);
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/job/${job.plainId}?region=${region}`);
|
|
assert.equal(request.method, 'GET');
|
|
});
|
|
|
|
test('forcePeriodic requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
job.set('periodic', true);
|
|
|
|
await this.subject().forcePeriodic(job);
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(
|
|
request.url,
|
|
`/v1/job/${job.plainId}/periodic/force?region=${region}`
|
|
);
|
|
assert.equal(request.method, 'POST');
|
|
});
|
|
|
|
test('stop requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
|
|
await this.subject().stop(job);
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/job/${job.plainId}?region=${region}`);
|
|
assert.equal(request.method, 'DELETE');
|
|
});
|
|
|
|
test('parse requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
await this.initializeUI({ region });
|
|
|
|
await this.subject().parse('job "name-goes-here" {');
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/jobs/parse?namespace=*®ion=${region}`);
|
|
assert.equal(request.method, 'POST');
|
|
assert.deepEqual(JSON.parse(request.requestBody), {
|
|
JobHCL: 'job "name-goes-here" {',
|
|
Canonicalize: true,
|
|
});
|
|
});
|
|
|
|
test('plan requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
job.set('_newDefinitionJSON', {});
|
|
|
|
await this.subject().plan(job);
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/job/${job.plainId}/plan?region=${region}`);
|
|
assert.equal(request.method, 'POST');
|
|
});
|
|
|
|
test('run requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
job.set('_newDefinitionJSON', {});
|
|
|
|
await this.subject().run(job);
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/jobs?region=${region}`);
|
|
assert.equal(request.method, 'POST');
|
|
});
|
|
|
|
test('update requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
job.set('_newDefinitionJSON', {});
|
|
|
|
await this.subject().update(job);
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/job/${job.plainId}?region=${region}`);
|
|
assert.equal(request.method, 'POST');
|
|
});
|
|
|
|
test('scale requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
|
|
await this.subject().scale(job, 'group-1', 5, 'Reason: a test');
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(request.url, `/v1/job/${job.plainId}/scale?region=${region}`);
|
|
assert.equal(request.method, 'POST');
|
|
});
|
|
|
|
test('dispatch requests include the activeRegion', async function (assert) {
|
|
const region = 'region-2';
|
|
const job = await this.initializeWithJob({ region });
|
|
job.set('parameterized', true);
|
|
|
|
await this.subject().dispatch(job, {}, '');
|
|
|
|
const request = this.server.pretender.handledRequests[0];
|
|
assert.equal(
|
|
request.url,
|
|
`/v1/job/${job.plainId}/dispatch?region=${region}`
|
|
);
|
|
assert.equal(request.method, 'POST');
|
|
});
|
|
});
|
|
|
|
function makeMockModel(id, options) {
|
|
return assign(
|
|
{
|
|
relationshipFor(name) {
|
|
return {
|
|
kind: 'belongsTo',
|
|
type: 'job-summary',
|
|
key: name,
|
|
};
|
|
},
|
|
belongsTo(name) {
|
|
return {
|
|
link() {
|
|
return `/v1/job/${id}/${name}`;
|
|
},
|
|
};
|
|
},
|
|
},
|
|
options
|
|
);
|
|
}
|