Fixture valid optimizations (#506)

Some changes in fixture-valid test, extracted from #425:
* Add checkCapability function
* Refactor category suggestion / validation
* Add missing focus types "Head" in fixtures
* Remove outdated reference to module.exports
* Add JSDoc

Author: fxedel

fixtures/adb/warp-m.json

@@ -20,6 +20,7 @@
       "colorTemperature": 3200
     },
     "focus": {
+      "type": "Head",
       "panMax": 400,
       "tiltMax": 275
     }

fixtures/jb-lighting/varyscan-p7.json

@@ -22,6 +22,7 @@
       "degreesMinMax": [8, 48]
     },
     "focus": {
+      "type": "Head",
       "panMax": 433.6,
       "tiltMax": 280
     }

tests/fixture-valid.js

@@ -362,20 +362,7 @@ function checkFixture(manKey, fixKey, fixtureJson, uniqueValues = null) {
           rangesInvalid = !checkRange(i);
         }
 
-        const switchingChannelAliases = Object.keys(cap.switchChannels);
-        if (!arraysEqual(switchingChannelAliases, channel.switchingChannelAliases)) {
-          result.errors.push(`Capability '${cap.name}' (#${i + 1}) must define the same switching channel aliases as all other capabilities in channel '${channel.key}'.`);
-        }
-        else {
-          for (const alias of switchingChannelAliases) {
-            const chKey = cap.switchChannels[alias];
-            usedChannelKeys.add(chKey.toLowerCase());
-
-            if (channel.fixture.getChannelByKey(chKey) === null) {
-              result.errors.push(`Channel '${chKey}' is referenced from capability '${cap.name}' (#${i + 1}) in channel '${channel.key}' but is not defined.`);
-            }
-          }
-        }
+        checkCapability(cap, `Capability '${cap.name}' (${cap.rawDmxRange}) in channel '${channel.key}'`);
       }
 
       /**
@@ -434,6 +421,28 @@ function checkFixture(manKey, fixKey, fixtureJson, uniqueValues = null) {
 
         return values;
       }
+
+      /**
+       * Check that a capability is valid (except its DMX range).
+       * @param {!Capability} cap The capability to check.
+       * @param {!string} errorPrefix An identifier for the capability to use in errors and warnings.
+       */
+      function checkCapability(cap, errorPrefix) {
+        const switchingChannelAliases = Object.keys(cap.switchChannels);
+        if (!arraysEqual(switchingChannelAliases, channel.switchingChannelAliases)) {
+          result.errors.push(`${errorPrefix} must define the same switching channel aliases as all other capabilities.`);
+        }
+        else {
+          switchingChannelAliases.forEach(alias => {
+            const chKey = cap.switchChannels[alias];
+            usedChannelKeys.add(chKey.toLowerCase());
+
+            if (channel.fixture.getChannelByKey(chKey) === null) {
+              result.errors.push(`${errorPrefix} references unknown channel '${chKey}'.`);
+            }
+          });
+        }
+      }
     }
   }
 
@@ -707,41 +716,107 @@ function checkFixture(manKey, fixKey, fixtureJson, uniqueValues = null) {
    * Checks if the used channels fits to the fixture's categories and raise warnings suggesting to add/remove a category.
    */
   function checkCategories() {
-    const fixtureChannels = fixture.availableChannels.concat(fixture.matrixChannels.map(matrixCh => matrixCh.wrappedChannel));
+    const categories = {
+      'Color Changer': {
+        isSuggested: isColorChanger(),
+        suggestedPhrase: `there are at least one 'Multi-Color' or two 'Single Color' channels`,
+        invalidPhrase: `there is no 'Multi-Color' and less than two 'Single Color' channels`
+      },
+      'Moving Head': {
+        isSuggested: isMovingHead(),
+        isInvalid: isNotMovingHead(),
+        suggestedPhrase: `focus.type is 'Head' or there's a 'Pan' and a 'Tilt' capability`,
+        invalidPhrase: `focus.type is not 'Head'`
+      },
+      'Scanner': {
+        isSuggested: isScanner(),
+        isInvalid: isNotScanner(),
+        suggestedPhrase: `focus.type is 'Mirror' or there's a 'Pan' and a 'Tilt' capability`,
+        invalidPhrase: `focus.type is not 'Mirror'`
+      },
+      'Smoke': {
+        isInvalid: !hasChannelOfType(`Fog`),
+        invalidPhrase: `there is not 'Fog' channel.`
+      },
+      'Hazer': {
+        isInvalid: !hasChannelOfType(`Fog`),
+        invalidPhrase: `there is not 'Fog' channel.`
+      }
+    };
+
+    for (const categoryName of Object.keys(categories)) {
+      const categoryUsed = fixture.categories.includes(categoryName);
+      const category = categories[categoryName];
 
-    const hasMultiColorChannel = fixtureChannels.some(channel => channel.type === `Multi-Color`);
-    const hasMultipleSingleColorChannels = fixtureChannels.filter(channel => channel.type === `Single Color`).length > 1;
-    const hasColorChangerCategory = fixture.categories.includes(`Color Changer`);
-    if (!hasColorChangerCategory && hasMultiColorChannel) {
-      result.warnings.push(`Category 'Color Changer' suggested since there is a 'Multi-Color' channel.`);
+      if (!(`isInvalid` in category)) {
+        category.isInvalid = !category.isSuggested;
+      }
+
+      if (!categoryUsed && category.isSuggested) {
+        result.warnings.push(`Category '${categoryName}' suggested since ${category.suggestedPhrase}.`);
+      }
+      else if (categoryUsed && category.isInvalid) {
+        result.errors.push(`Category '${categoryName}' invalid since ${category.invalidPhrase}.`);
+      }
     }
-    else if (!hasColorChangerCategory && hasMultipleSingleColorChannels) {
-      result.warnings.push(`Category 'Color Changer' suggested since there are multiple 'Single Color' channels.`);
+
+    /**
+     * @returns {!boolean} Whether the 'Color Changer' category is suggested.
+    */
+    function isColorChanger() {
+      return hasChannelOfType(`Multi-Color`) || hasChannelOfType(`Single Color`, 2);
     }
-    else if (hasColorChangerCategory && !hasMultiColorChannel && !hasMultipleSingleColorChannels) {
-      result.warnings.push(`Category 'Color Changer' invalid since there is no 'Multi-Color' and less than 2 'Single Color' channels.`);
+
+    /**
+     * @returns {!boolean} Whether the 'Moving Head' category is suggested.
+    */
+    function isMovingHead() {
+      const hasFocusTypeHead = fixture.physical !== null && fixture.physical.focusType === `Head`;
+      const hasOtherFocusType = fixture.physical !== null && fixture.physical.focusType !== null;
+
+      return hasFocusTypeHead || (hasPanTiltChannels() && !hasOtherFocusType);
     }
 
-    const hasFocusTypeHead = fixture.physical !== null && fixture.physical.focusType === `Head`;
-    const hasMovingHeadCategory = fixture.categories.includes(`Moving Head`);
-    if (!hasMovingHeadCategory && hasFocusTypeHead) {
-      result.warnings.push(`Category 'Moving Head' suggested since focus.type is 'Head'.`);
+    /**
+     * @returns {!boolean} Whether the 'Moving Head' category is invalid.
+    */
+    function isNotMovingHead() {
+      return fixture.physical === null || fixture.physical.focusType !== `Head`;
     }
-    else if (hasMovingHeadCategory && !hasFocusTypeHead) {
-      result.warnings.push(`Category 'Moving Head' invalid since focus.type is not 'Head'.`);
+
+    /**
+     * @returns {!boolean} Whether the 'Scanner' category is suggested.
+    */
+    function isScanner() {
+      const hasFocusTypeMirror = fixture.physical !== null && fixture.physical.focusType === `Mirror`;
+      const hasOtherFocusType = fixture.physical !== null && fixture.physical.focusType !== null;
+
+      return hasFocusTypeMirror || (hasPanTiltChannels() && !hasOtherFocusType);
     }
 
-    const hasFogChannel = fixtureChannels.some(channel => channel.type === `Fog`);
-    const hasSmokeCategory = fixture.categories.includes(`Smoke`);
-    const hasHazerCategory = fixture.categories.includes(`Hazer`);
-    if (!(hasSmokeCategory || hasHazerCategory) && hasFogChannel) {
-      result.warnings.push(`Categories 'Smoke' and/or 'Hazer' suggested since there is a 'Fog' channel.`);
+    /**
+     * @returns {!boolean} Whether the 'Scanner' category is invalid.
+    */
+    function isNotScanner() {
+      return fixture.physical === null || fixture.physical.focusType !== `Mirror`;
     }
-    else if (hasSmokeCategory && !hasFogChannel) {
-      result.warnings.push(`Category 'Smoke' invalid since there is no 'Fog' channel.`);
+
+    /**
+     * @returns {!boolean} Whether the fixture has both a Pan and a Tilt channel.
+     */
+    function hasPanTiltChannels() {
+      return hasChannelOfType(`Pan`) && hasChannelOfType(`Tilt`);
     }
-    else if (hasHazerCategory && !hasFogChannel) {
-      result.warnings.push(`Category 'Hazer' invalid since there is no 'Fog' channel.`);
+
+    /**
+     * @param {!string} type What channel type to search for.
+     * @param {!number} [minimum=1] How many occurences are needed to succeed.
+     * @returns {!boolean} Whether the given channel type occurs at least at the given minimum times in the fixture.
+     */
+    function hasChannelOfType(type, minimum = 1) {
+      return fixture.normalizedChannels.filter(
+        ch => ch.type === type
+      ).length >= minimum;
     }
   }
 

tests/fixtures-valid.js

@@ -43,6 +43,11 @@ for (const manKey of fs.readdirSync(fixturePath)) {
   }
 }
 
+/**
+ * Checks (asynchronously) the given fixture by adding a Promise to the promises array that resolves with a result object.
+ * @param {!string} manKey The manufacturer key.
+ * @param {!string} fixKey The fixture key.
+ */
 function handleFixtureFile(manKey, fixKey) {
   const filename = `${manKey}/${fixKey}.json`;
   const result = {
@@ -109,7 +114,7 @@ promises.push(new Promise((resolve, reject) => {
     const validate = (new Ajv()).compile(manufacturerSchema);
     const valid = validate(manufacturers);
     if (!valid) {
-      result.errors.push(module.exports.getErrorString(`File does not match schema.`, validate.errors));
+      result.errors.push(getErrorString(`File does not match schema.`, validate.errors));
       return resolve(result);
     }