Fix obsolete test

test/linter/test-obsolete.test.ts

@@ -68,6 +68,7 @@ describe('neverImplemented', () => {
 
 describe('implementedAndRemoved', () => {
   it('returns false for features which were implemented and never removed', () => {
+    assert.ok(release);
     assert.equal(
       implementedAndRemoved({
         chrome: { version_added: '1' },
@@ -94,6 +95,34 @@ describe('implementedAndRemoved', () => {
       }),
       false,
     );
+    assert.equal(
+      implementedAndRemoved({
+        chrome: [
+          {
+            version_added: '2',
+            version_removed: release[0],
+          },
+          {
+            version_added: '1',
+            version_removed: '2',
+            flags: [
+              {
+                type: 'preference',
+                name: 'flag',
+              },
+            ],
+          },
+        ],
+        chrome_android: 'mirror',
+        firefox: {
+          version_added: false,
+        },
+        safari: {
+          version_added: '6',
+        },
+      }),
+      false,
+    );
   });
 
   it('returns false for features which were implemented and removed recently', () => {
@@ -163,6 +192,31 @@ describe('implementedAndRemoved', () => {
       }),
       'warning',
     );
+    assert.equal(
+      implementedAndRemoved({
+        chrome: [
+          {
+            version_added: '2',
+            version_removed,
+          },
+          {
+            version_added: '1',
+            version_removed: '2',
+            flags: [
+              {
+                type: 'preference',
+                name: 'flag',
+              },
+            ],
+          },
+        ],
+        chrome_android: 'mirror',
+        firefox: {
+          version_added: false,
+        },
+      }),
+      'warning',
+    );
   });
 });
 

test/linter/test-obsolete.ts

@@ -4,22 +4,34 @@
 import chalk from 'chalk-template';
 
 import { Linter, Logger, LinterData, LinterMessageLevel } from '../utils.js';
+import { BrowserName, CompatStatement } from '../../types/types.js';
 import {
-  BrowserName,
-  CompatStatement,
-  SupportBlock,
-  SupportStatement,
-} from '../../types/types.js';
+  InternalSupportBlock,
+  InternalSupportStatement,
+} from '../../types/index.js';
 import bcd from '../../index.js';
 const { browsers } = bcd;
 
+// Once a category has been stripped of unsupported features, add it to this list
+const categoriesToCheck = [
+  'api',
+  // 'css',
+  // 'html',
+  // 'http',
+  // 'javascript',
+  // 'mathml',
+  // 'svg',
+  // 'webdriver',
+  // 'webextensions'
+];
+
 /**
  * Check if feature has never been implemented
  *
- * @param {SupportBlock} support The support statement
+ * @param {InternalSupportBlock} support The support statement
  * @returns {boolean} If the feature was never implemented
  */
-export const neverImplemented = (support: SupportBlock): boolean => {
+export const neverImplemented = (support: InternalSupportBlock): boolean => {
   for (const s in support) {
     let data = support[s];
     if (!Array.isArray(data)) {
@@ -42,23 +54,33 @@ warningTime.setFullYear(warningTime.getFullYear() - 2);
 /**
  * Check if a feature has been implemented at some point but removed now
  *
- * @param {SupportBlock} support The support statement
+ * @param {InternalSupportBlock} support The support statement
  * @returns {LinterMessageLevel | false} Whether the feature should be removed from BCD
  */
 export const implementedAndRemoved = (
-  support: SupportBlock,
+  support: InternalSupportBlock,
 ): LinterMessageLevel | false => {
   let result: LinterMessageLevel = 'error';
   for (const [browser, data] of Object.entries(support) as [
     BrowserName,
-    SupportStatement,
+    InternalSupportStatement,
   ][]) {
     if (browser === 'ie') {
       // Don't consider IE support in obsolete checks
       continue;
     }
 
+    // Feature is set to mirror; issues will come up in upstream browsers, ignore
+    if (data === 'mirror') {
+      continue;
+    }
+
     for (const d of Array.isArray(data) ? data : [data]) {
+      // Feature not supported and not being worked on; test other browsers
+      if (d.version_added === false && !d.impl_url) {
+        continue;
+      }
+
       // Feature is still supported or it is not known when feature was dropped
       if (!d.version_removed || typeof d.version_removed === 'boolean') {
         return false;
@@ -94,19 +116,16 @@ export const implementedAndRemoved = (
  */
 export const processData = (logger: Logger, data: CompatStatement): void => {
   if (data && data.support) {
-    const { support, status } = data;
-
-    const abandoned = status && status.standard_track === false;
-    const rule1Fail = abandoned && neverImplemented(support);
+    const rule1Fail = neverImplemented(data.support);
     if (rule1Fail) {
-      logger.error(
-        chalk`feature was never implemented in any browser and the specification has been abandoned.`,
-      );
+      logger.error(chalk`feature was never implemented.`);
+
+      // No need to perform the next check if the first one fails
       return;
     }
 
     // Note: This check is time-based
-    const rule2Fail = implementedAndRemoved(support);
+    const rule2Fail = implementedAndRemoved(data.support);
     if (rule2Fail) {
       logger[rule2Fail](
         chalk`feature was implemented and has since been removed from all browsers dating back two or more years ago.`,
@@ -125,16 +144,19 @@ export default {
    * @param {Logger} logger The logger to output errors to
    * @param {LinterData} root The data to test
    */
-  check: (logger: Logger, { data }: LinterData) => {
-    processData(logger, data);
+  check: (logger: Logger, { data, path: { category } }: LinterData) => {
+    if (categoriesToCheck.includes(category)) {
+      processData(logger, data);
+    }
   },
-  exceptions: [
-    'http.headers.Cache-Control.stale-if-error',
-    'http.headers.Feature-Policy.layout-animations',
-    'http.headers.Feature-Policy.legacy-image-formats',
-    'http.headers.Feature-Policy.oversized-images',
-    'http.headers.Feature-Policy.unoptimized-images',
-    'http.headers.Feature-Policy.unsized-media',
-    'svg.elements.view.zoomAndPan',
-  ],
+  // XXX Exceptions disabled while the corresponding categories are ignored
+  // exceptions: [
+  // 'http.headers.Cache-Control.stale-if-error',
+  // 'http.headers.Feature-Policy.layout-animations',
+  // 'http.headers.Feature-Policy.legacy-image-formats',
+  // 'http.headers.Feature-Policy.oversized-images',
+  // 'http.headers.Feature-Policy.unoptimized-images',
+  // 'http.headers.Feature-Policy.unsized-media',
+  // 'svg.elements.view.zoomAndPan',
+  // ],
 } as Linter;