Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Update unit tests invalidated by legacy removal changes #183

Merged
merged 4 commits into from
Jul 12, 2024
Merged

Update unit tests invalidated by legacy removal changes #183

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
78b8844
update type composition policy tests
jvigliotta Jun 27, 2024
8bed57a
update export data tast tests
jvigliotta Jun 27, 2024
03cbc9d
final test update
jvigliotta Jul 11, 2024
d71b1dc
remove unnecessary code change
jvigliotta Jul 12, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 4 additions & 2 deletions src/exportDataAction/ExportDataAction.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -66,10 +66,12 @@ class ExportDataAction {
}
}

runExportTask(domainObjects) {
async runExportTask(domainObjects) {
const task = new ExportDataTask(this.openmct, domainObjects[0].name, domainObjects);

return task.invoke();
await task.invoke();

return;
}

isValidType(domainObject) {
Expand Down
314 changes: 146 additions & 168 deletions src/exportDataAction/ExportDataActionSpec.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,220 +1,198 @@
/*global define,describe,beforeEach,jasmine,spyOn,Promise,it,expect,waitsFor,runs,afterEach*/

define([
'../src/ExportDataAction'
], function (ExportDataAction) {
'use strict';

xdescribe("The Export Data action", function () {
var mockExportService,
openmct,
mockTelemetryObject,
mockRealtimeOnlyTelemetryObject,
mockDelegatingObject,
mockDelegateObjects,
mockNotification,
mockCallback,
telemetryPromises,
telemetryRequested;

function makeMockDomainObject(id, capabilities, realtimeOnly) {
var mockDomainObject = jasmine.createSpyObj('object-' + id, [
'getId',
'getModel',
'hasCapability',
'useCapability',
'getCapability'
]);
mockDomainObject.getId.and.returnValue(id);
mockDomainObject.getModel.and.returnValue({telemetry: {realtimeOnly: realtimeOnly}});
mockDomainObject.hasCapability.and.callFake(function (c) {
return !!(capabilities[c]);
});
mockDomainObject.getCapability.and.callFake(function (c) {
return capabilities[c];
});
mockDomainObject.useCapability.and.callFake(function (c) {
return capabilities[c].invoke();
});
'./ExportDataAction'
], (ExportDataActionModule) => {
const ExportDataAction = ExportDataActionModule.default;

describe('The Export Data action', () => {
let mockOpenmct;
let mockCompositionCollection;
let mockComposition;
let mockTelemetryObject;
let mockRealtimeOnlyTelemetryObject;
let mockTelemetryObjectWithComposition;
let mockNotification;
let telemetryPromises;
let exportDataAction;
let telemetryRequested;
let telemetryRequestCount;

function makeMockDomainObject(id, telemetry, realtimeOnly) {
let mockDomainObject = {
identifier: {
namespace: 'object',
key: id
},
type: 'validType',
}

if (telemetry) {
mockDomainObject.telemetry = {};
}

if (realtimeOnly) {
mockDomainObject.realtimeOnly = true;
}

return mockDomainObject;
}

function telemetryPromise() {
return new Promise(function (resolve, reject) {
telemetryPromises.push({ resolve: resolve, reject: reject });
return new Promise((resolve, reject) => {
telemetryPromises.push({ resolve, reject });
setTimeout(telemetryRequested);
});
}

function makeMockTelemetryObject(id) {
var mockTelemetry = jasmine.createSpyObj('telemetry-' + id, [
'requestData',
'subscribe'
]);
mockTelemetry.requestData.and.callFake(telemetryPromise);
return makeMockDomainObject(id, { telemetry: mockTelemetry });
}

function makeMockRealtimeOnlyTelemetryObject(id) {
var mockTelemetry = jasmine.createSpyObj('telemetry-' + id, [
'requestData',
'subscribe'
]);
mockTelemetry.requestData.and.callFake(telemetryPromise);
return makeMockDomainObject(id, { telemetry: mockTelemetry }, true);
}

beforeEach(function () {
var mockCapabilities = {
composition: jasmine.createSpyObj('composition', ['invoke']),
delegation: jasmine.createSpyObj(
'delegation',
['doesDelegateCapability']
)
};

beforeEach(() => {
telemetryPromises = [];
telemetryRequested = jasmine.createSpy('telemetryRequested');
telemetryRequested = jasmine.createSpy('telemetryRequested').and.callFake(() => {
telemetryRequestCount--;
if (telemetryRequestCount === 0) {
telemetryRequested.done();
}
});

openmct = jasmine.createSpyObj('openmct',
mockOpenmct = jasmine.createSpyObj('mockOpenmct',
[
'overlays',
'notifications'
'notifications',
'composition',
'telemetry'
]
);
openmct.notifications = jasmine.createSpyObj('notificationService',
['error']
);
openmct.overlays = jasmine.createSpyObj('overlays',
['progressDialog']
);
mockExportService = jasmine.createSpyObj(
'exportService',
['exportCSV']
mockTelemetry = [];
mockCompositionCollection = jasmine.createSpyObj('compositionCollection', ['load']);
mockCompositionCollection.load.and.returnValue(Promise.resolve(mockComposition));
mockOpenmct.composition = jasmine.createSpyObj('composition', ['get']);
mockOpenmct.composition.get.and.returnValue(mockCompositionCollection);
mockOpenmct.telemetry = jasmine.createSpyObj('telemetry', ['isTelemetryObject', 'request']);
mockOpenmct.telemetry.request.and.callFake(telemetryPromise);
mockOpenmct.telemetry.isTelemetryObject.and.callFake((object) => {
return object.telemetry;
});
mockOpenmct.notifications = jasmine.createSpyObj('notificationService',
[
'error',
'progress',
'info'
]
);
mockNotification = jasmine.createSpyObj('notification', ['dismiss']);
mockTelemetryObject = makeMockTelemetryObject('singular');
mockRealtimeOnlyTelemetryObject = makeMockRealtimeOnlyTelemetryObject('singular');
mockDelegateObjects =
['a', 'b', 'c'].map(makeMockTelemetryObject);
mockDelegatingObject =
makeMockDomainObject('delegator', mockCapabilities);

openmct.overlays.progressDialog.and.returnValue(mockNotification);

mockCapabilities.delegation.doesDelegateCapability
.and.callFake(function (c) {
return c === 'telemetry';
});
mockCapabilities.composition.invoke
.and.returnValue(Promise.resolve(mockDelegateObjects));

mockCallback = jasmine.createSpy('callback');
});

mockTelemetryObject = makeMockDomainObject('singular', true);
mockRealtimeOnlyTelemetryObject = makeMockDomainObject('singular', true, true);
mockTelemetryObjectWithComposition = makeMockDomainObject('composition');

it("applies to objects with a telemetry capability", function () {
expect(ExportDataAction.appliesTo({
domainObject: mockTelemetryObject
})).toBe(true);
});
mockOpenmct.notifications.progress.and.returnValue(mockNotification);

it("applies to objects which delegate the telemetry capability", function () {
expect(ExportDataAction.appliesTo({
domainObject: mockDelegatingObject
})).toBe(true);
exportDataAction = new ExportDataAction(
mockOpenmct,
['validType']
);
});

it("does not apply to objects with no such capabilities", function () {
expect(ExportDataAction.appliesTo({
domainObject: makeMockDomainObject('foo', {})
})).toBe(false);
it('applies to objects with a valid type', () => {
expect(exportDataAction.appliesTo([mockTelemetryObject])).toBe(true);
});

it("does not apply to realtime only telemetry objects", function () {
expect(ExportDataAction.appliesTo({
domainObject: mockRealtimeOnlyTelemetryObject
})).toBe(false);
it('does not apply to realtime only telemetry objects', (done) => {
telemetryRequested.and.callFake(done);
exportDataAction.invoke([mockRealtimeOnlyTelemetryObject]).then(() => {
expect(mockOpenmct.notifications.info).toHaveBeenCalledWith('No historical data to export');
});
});


[ false, true ].forEach(function (singular) {
var targetDescription = singular ?
"a single object" : "multiple objects";

describe("when performed on " + targetDescription, function () {
var mockTarget;

beforeEach(function (done) {
mockTarget = singular ?
mockTelemetryObject : mockDelegatingObject;
telemetryRequested.and.callFake(done);

new ExportDataAction(
mockExportService,
openmct,
{ domainObject: mockTarget }
).perform().then(mockCallback);
[ false, true ].forEach((singular) => {
let targetDescription;

if (singular) {
targetDescription = 'a single object';
} else {
targetDescription = 'multiple objects';
mockComposition = [
makeMockDomainObject('composition-1', true),
makeMockDomainObject('composition-2', true)
];
}

describe('when performed on ' + targetDescription, () => {
let mockTarget;

beforeEach((done) => {
let doneCalled = false;
const callDoneOnce = () => {
if (!doneCalled) {
doneCalled = true;
done();
}
};

spyOn(exportDataAction, 'runExportTask').and.callThrough();
spyOn(exportDataAction, 'exportCompositionData').and.callThrough();
mockTarget = singular ? mockTelemetryObject : mockTelemetryObjectWithComposition;
telemetryRequestCount = singular ? 1 : mockComposition.length;
telemetryRequested.done = callDoneOnce;
exportDataAction.invoke([mockTarget]).finally(callDoneOnce);
});

it("shows a progress notification", function () {
expect(openmct.overlays.progressDialog)
.toHaveBeenCalled();
it('shows a progress notification', () => {
expect(mockOpenmct.notifications.progress).toHaveBeenCalled();
});

if (singular) {
it("initiates a telemetry request", function () {
it('initiates a telemetry request', () => {
expect(telemetryPromises.length).toEqual(1);
});
} else {
it("initiates telemetry requests", function () {
expect(telemetryPromises.length)
.toEqual(mockDelegateObjects.length);
it('initiates telemetry requests', () => {
expect(telemetryPromises.length).toEqual(mockComposition.length);
});
}

describe("and data is provided", function () {
beforeEach(function (done) {
mockCallback.and.callFake(done);

telemetryPromises.forEach(function (p, i) {
var mockSeries = jasmine.createSpyObj(
'series-' + i,
[ 'getData' ]
);
mockSeries.getData.and.returnValue([]);
p.resolve(mockSeries);
describe('and data is provided', () => {
beforeEach((done) => {
telemetryPromises.forEach((promise) => {
promise.resolve([]);
});
setTimeout(done, 0); // Ensure all promises are resolved
});

it("dismisses its progress notification", function () {
expect(mockNotification.dismiss)
.toHaveBeenCalled();
it('does not show an error notification', () => {
expect(mockOpenmct.notifications.error).not.toHaveBeenCalled();
});

it("triggers a CSV export", function () {
expect(mockExportService.exportCSV)
.toHaveBeenCalledWith(
jasmine.any(Array),
{ headers: jasmine.any(Array) }
);
it('dismisses its progress notification', (done) => {
setTimeout(() => {
expect(mockNotification.dismiss).toHaveBeenCalled();
done();
}, 0);
});

if (singular) {
it('triggers a CSV export for one object', () => {
expect(exportDataAction.runExportTask).toHaveBeenCalled();
});
} else {
it('triggers a CSV export for each object', () => {
expect(exportDataAction.exportCompositionData).toHaveBeenCalled();
});
}
});

describe("and a request failure occurs", function () {
beforeEach(function (done) {
mockCallback.and.callFake(done);
telemetryPromises[0].reject();
describe('and a request failure occurs', () => {
beforeEach((done) => {
telemetryPromises.forEach((promise) => {
promise.reject();
});
done();
});

it("dismisses its progress notification", function () {
expect(mockNotification.dismiss)
.toHaveBeenCalled();
it('dismisses its progress notification', () => {
expect(mockNotification.dismiss).toHaveBeenCalled();
});

it("displays an error notification", function () {
expect(openmct.notifications.error)
.toHaveBeenCalled();
it('displays an error notification', () => {
expect(mockOpenmct.notifications.error).toHaveBeenCalled();
});
});

Expand Down
2 changes: 1 addition & 1 deletion src/exportDataAction/ExportDataTask.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,7 +29,7 @@ export default class ExportDataTask {
}

async fetchAllTelemetryData() {
return Promise.all(this.domainObjects.map(async (domainObject) => {
return Promise.all(this.domainObjects.map((domainObject) => {
return this.openmct.telemetry.request(domainObject, { strategy: 'comprehensive' });
}));
}
Expand Down
Loading