Refresh openmct require cache before each test

package.json

@@ -53,9 +53,9 @@
     "marked": "^0.3.5",
     "mini-css-extract-plugin": "^0.4.1",
     "minimist": "^1.1.1",
-    "moment": "2.25.3",
+    "moment": "^2.11.1",
     "moment-duration-format": "^2.2.2",
-    "moment-timezone": "0.5.28",
+    "moment-timezone": "^0.5.21",
     "node-bourbon": "^4.2.3",
     "node-sass": "^4.9.2",
     "painterro": "^0.2.65",

src/plugins/condition/Condition.js

@@ -69,7 +69,9 @@ export default class ConditionClass extends EventEmitter {
             console.log('no data received');
             return;
         }
-
+        if (!this.isTelemetryUsed(datum.id)) {
+            return;
+        }
         this.criteria.forEach(criterion => {
             if (this.isAnyOrAllTelemetry(criterion)) {
                 criterion.getResult(datum, this.conditionManager.telemetryObjects);
@@ -204,7 +206,7 @@ export default class ConditionClass extends EventEmitter {
         let latestTimestamp;
         let criteriaResults = {};
         const criteriaRequests = this.criteria
-            .map(criterion => criterion.requestLAD(this.conditionManager.telemetryObjects));
+            .map(criterion => criterion.requestLAD({telemetryObjects: this.conditionManager.telemetryObjects}));
 
         return Promise.all(criteriaRequests)
             .then(results => {

src/plugins/condition/ConditionManager.js

@@ -55,8 +55,9 @@ export default class ConditionManager extends EventEmitter {
         this.telemetryObjects[id] = Object.assign({}, endpoint, {telemetryMetaData: this.openmct.telemetry.getMetadata(endpoint).valueMetadatas});
         this.subscriptions[id] = this.openmct.telemetry.subscribe(
             endpoint,
-            this.telemetryReceived.bind(this, endpoint)
+            this.telemetryReceived.bind(this, id)
         );
+        // TODO check if this is needed
         this.updateConditionTelemetry();
     }
 
@@ -70,7 +71,6 @@ export default class ConditionManager extends EventEmitter {
         this.subscriptions[id]();
         delete this.subscriptions[id];
         delete this.telemetryObjects[id];
-        this.removeConditionTelemetry();
     }
 
     initialize() {
@@ -86,30 +86,6 @@ export default class ConditionManager extends EventEmitter {
         this.conditionClassCollection.forEach((condition) => condition.updateTelemetry());
     }
 
-    removeConditionTelemetry() {
-        let conditionsChanged = false;
-        this.conditionSetDomainObject.configuration.conditionCollection.forEach((conditionConfiguration) => {
-            conditionConfiguration.configuration.criteria.forEach((criterion, index) => {
-                const isAnyAllTelemetry = criterion.telemetry && (criterion.telemetry === 'any' || criterion.telemetry === 'all');
-                if (!isAnyAllTelemetry) {
-                    const found = Object.values(this.telemetryObjects).find((telemetryObject) => {
-                        return this.openmct.objects.areIdsEqual(telemetryObject.identifier, criterion.telemetry);
-                    });
-                    if (!found) {
-                        criterion.telemetry = '';
-                        criterion.metadata = '';
-                        criterion.input = [];
-                        criterion.operation = '';
-                        conditionsChanged = true;
-                    }
-                }
-            });
-        });
-        if (conditionsChanged) {
-            this.persistConditions();
-        }
-    }
-
     updateCondition(conditionConfiguration, index) {
         let condition = this.conditionClassCollection[index];
         condition.update(conditionConfiguration);
@@ -258,13 +234,9 @@ export default class ConditionManager extends EventEmitter {
                             this.openmct.time.timeSystem()
                         );
                     });
-
-                    if (!Object.values(latestTimestamp).some(timeSystem => timeSystem)) {
-                        return [];
-                    }
-
                     const currentCondition = this.getCurrentConditionLAD(conditionResults);
-                    const currentOutput = Object.assign(
+
+                    return Object.assign(
                         {
                             output: currentCondition.configuration.output,
                             id: this.conditionSetDomainObject.identifier,
@@ -272,30 +244,12 @@ export default class ConditionManager extends EventEmitter {
                         },
                         latestTimestamp
                     );
-
-                    return [currentOutput];
                 });
         });
     }
 
-    isTelemetryUsed(endpoint) {
-        const id = this.openmct.objects.makeKeyString(endpoint.identifier);
-
-        for(const condition of this.conditionClassCollection) {
-            if (condition.isTelemetryUsed(id)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    telemetryReceived(endpoint, datum) {
-        if (!this.isTelemetryUsed(endpoint)) {
-            return;
-        }
-
-        const normalizedDatum = this.createNormalizedDatum(datum, endpoint);
+    telemetryReceived(id, datum) {
+        const normalizedDatum = this.createNormalizedDatum(datum, id);
         const timeSystemKey = this.openmct.time.timeSystem().key;
         let timestamp = {};
         timestamp[timeSystemKey] = normalizedDatum[timeSystemKey];
@@ -329,11 +283,8 @@ export default class ConditionManager extends EventEmitter {
         return data;
     }
 
-    createNormalizedDatum(telemetryDatum, endpoint) {
-        const id = this.openmct.objects.makeKeyString(endpoint.identifier);
-        const metadata = this.openmct.telemetry.getMetadata(endpoint).valueMetadatas;
-
-        const normalizedDatum = Object.values(metadata).reduce((datum, metadatum) => {
+    createNormalizedDatum(telemetryDatum, id) {
+        const normalizedDatum = Object.values(this.telemetryObjects[id].telemetryMetaData).reduce((datum, metadatum) => {
             const testValue = this.getTestData(metadatum);
             const formatter = this.openmct.telemetry.getValueFormatter(metadatum);
             datum[metadatum.key] = testValue !== undefined ?  formatter.parse(testValue) : formatter.parse(telemetryDatum[metadatum.source]);

src/plugins/condition/ConditionSetMetadataProvider.js

@@ -54,22 +54,13 @@ export default class ConditionSetMetadataProvider {
         return {
             values: this.getDomains().concat([
                 {
-                    key: "state",
-                    source: "output",
-                    name: "State",
-                    format: "enum",
+                    name: 'Output',
+                    key: 'output',
+                    format: 'enum',
                     enumerations: enumerations,
                     hints: {
                         range: 1
                     }
-                },
-                {
-                    key: "output",
-                    name: "Value",
-                    format: "string",
-                    hints: {
-                        range: 2
-                    }
                 }
             ])
         };

src/plugins/condition/ConditionSetTelemetryProvider.js

@@ -45,7 +45,7 @@ export default class ConditionSetTelemetryProvider {
 
         return conditionManager.requestLADConditionSetOutput()
             .then(latestOutput => {
-                return latestOutput;
+                return latestOutput ? [latestOutput] : [];
             });
     }
 

src/plugins/condition/criterion/AllTelemetryCriterion.js

@@ -22,7 +22,6 @@
 
 import TelemetryCriterion from './TelemetryCriterion';
 import { evaluateResults } from "../utils/evaluator";
-import { getLatestTimestamp } from '../utils/time';
 
 export default class AllTelemetryCriterion extends TelemetryCriterion {
 
@@ -48,21 +47,6 @@ export default class AllTelemetryCriterion extends TelemetryCriterion {
 
     updateTelemetry(telemetryObjects) {
         this.telemetryObjects = { ...telemetryObjects };
-        this.removeTelemetryDataCache();
-    }
-
-    removeTelemetryDataCache() {
-        const telemetryCacheIds = Object.keys(this.telemetryDataCache);
-        Object.values(this.telemetryObjects).forEach(telemetryObject => {
-            const id = this.openmct.objects.makeKeyString(telemetryObject.identifier);
-            const foundIndex = telemetryCacheIds.indexOf(id);
-            if (foundIndex > -1) {
-                telemetryCacheIds.splice(foundIndex, 1);
-            }
-        });
-        telemetryCacheIds.forEach(id => {
-            delete (this.telemetryDataCache[id]);
-        });
     }
 
     formatData(data, telemetryObjects) {
@@ -108,53 +92,40 @@ export default class AllTelemetryCriterion extends TelemetryCriterion {
         this.result = evaluateResults(Object.values(this.telemetryDataCache), this.telemetry);
     }
 
-    requestLAD(telemetryObjects) {
-        const options = {
-            strategy: 'latest',
-            size: 1
-        };
+    requestLAD(options) {
+        options = Object.assign({},
+            options,
+            {
+                strategy: 'latest',
+                size: 1
+            }
+        );
 
         if (!this.isValid()) {
-            return this.formatData({}, telemetryObjects);
+            return this.formatData({}, options.telemetryObjects);
         }
 
-        let keys = Object.keys(Object.assign({}, telemetryObjects));
+        let keys = Object.keys(Object.assign({}, options.telemetryObjects));
         const telemetryRequests = keys
             .map(key => this.openmct.telemetry.request(
-                telemetryObjects[key],
+                options.telemetryObjects[key],
                 options
             ));
 
-        let telemetryDataCache = {};
         return Promise.all(telemetryRequests)
             .then(telemetryRequestsResults => {
-                let latestTimestamp;
-                const timeSystems = this.openmct.time.getAllTimeSystems();
-                const timeSystem = this.openmct.time.timeSystem();
-
+                let latestDatum;
                 telemetryRequestsResults.forEach((results, index) => {
-                    const latestDatum = results.length ? results[results.length - 1] : {};
-                    const datumId = keys[index];
-                    const normalizedDatum = this.createNormalizedDatum(latestDatum, telemetryObjects[datumId]);
-
-                    telemetryDataCache[datumId] = this.computeResult(normalizedDatum);
-
-                    latestTimestamp = getLatestTimestamp(
-                        latestTimestamp,
-                        normalizedDatum,
-                        timeSystems,
-                        timeSystem
-                    );
+                    latestDatum = results.length ? results[results.length - 1] : {};
+                    if (index < telemetryRequestsResults.length-1) {
+                        if (latestDatum) {
+                            this.telemetryDataCache[latestDatum.id] = this.computeResult(latestDatum);
+                        }
+                    }
                 });
-
-                const datum = {
-                    result: evaluateResults(Object.values(telemetryDataCache), this.telemetry),
-                    ...latestTimestamp
-                };
-
                 return {
                     id: this.id,
-                    data: datum
+                    data: this.formatData(latestDatum, options.telemetryObjects)
                 };
             });
     }

src/plugins/condition/criterion/TelemetryCriterion.js

@@ -61,21 +61,6 @@ export default class TelemetryCriterion extends EventEmitter {
         this.telemetryObject = telemetryObjects[this.telemetryObjectIdAsString];
     }
 
-    createNormalizedDatum(telemetryDatum, endpoint) {
-        const id = this.openmct.objects.makeKeyString(endpoint.identifier);
-        const metadata = this.openmct.telemetry.getMetadata(endpoint).valueMetadatas;
-
-        const normalizedDatum = Object.values(metadata).reduce((datum, metadatum) => {
-            const formatter = this.openmct.telemetry.getValueFormatter(metadatum);
-            datum[metadatum.key] = formatter.parse(telemetryDatum[metadatum.source]);
-            return datum;
-        }, {});
-
-        normalizedDatum.id = id;
-
-        return normalizedDatum;
-    }
-
     formatData(data) {
         const datum = {
             result: this.computeResult(data)
@@ -94,11 +79,14 @@ export default class TelemetryCriterion extends EventEmitter {
         this.result = this.computeResult(validatedData);
     }
 
-    requestLAD() {
-        const options = {
-            strategy: 'latest',
-            size: 1
-        };
+    requestLAD(options) {
+        options = Object.assign({},
+            options,
+            {
+                strategy: 'latest',
+                size: 1
+            }
+        );
 
         if (!this.isValid()) {
             return {
@@ -112,11 +100,9 @@ export default class TelemetryCriterion extends EventEmitter {
             options
         ).then(results => {
             const latestDatum = results.length ? results[results.length - 1] : {};
-            const normalizedDatum = this.createNormalizedDatum(latestDatum, this.telemetryObject);
-
             return {
                 id: this.id,
-                data: this.formatData(normalizedDatum)
+                data: this.formatData(latestDatum)
             };
         });
     }

src/testTools.js

@@ -1,6 +1,8 @@
 import MCT from 'MCT';
 
 export function createOpenMct() {
+    delete require.cache[require.resolve('openmct')];
+
     const openmct = new MCT();
     openmct.install(openmct.plugins.LocalStorage());
     openmct.install(openmct.plugins.UTCTimeSystem());

src/ui/inspector/Inspector.vue

@@ -108,7 +108,7 @@ export default {
                 let object = selection[0][0].context.item;
                 if (object) {
                     let type = this.openmct.types.get(object.type);
-                    this.showStyles = this.isLayoutObject(selection[0], object.type) || this.isCreatableObject(object, type);
+                    this.showStyles = (this.excludeObjectTypes.indexOf(object.type) < 0) && type.definition.creatable;
                 }
                 if (!this.currentTabbedView.key || (!this.showStyles && this.currentTabbedView.key === this.tabbedViews[1].key))
                 {
@@ -116,14 +116,6 @@ export default {
                 }
             }
         },
-        isLayoutObject(selection, objectType) {
-            //we allow conditionSets to be styled if they're part of a layout
-            return selection.length > 1 &&
-                ((objectType === 'conditionSet') || (this.excludeObjectTypes.indexOf(objectType) < 0));
-        },
-        isCreatableObject(object, type) {
-            return (this.excludeObjectTypes.indexOf(object.type) < 0) && type.definition.creatable;
-        },
         updateCurrentTab(view) {
             this.currentTabbedView = view;
         },