@spinnaker/eslint-plugin 0.0.0-main-2

package/rules/ng-no-require-module-deps.ts

@@ -0,0 +1,211 @@
+import type { Rule } from 'eslint';
+import type { ArrayExpression, Node } from 'estree';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Prefer exporting a module's NAME instead of the entire angular.module()
+ *
+ * @version 0.1.0
+ * @category conventions
+ * @sinceAngularVersion 1.x
+ */
+const rule = function (context: Rule.RuleContext) {
+  return {
+    ArrayExpression: function (node: ArrayExpression) {
+      if (isInAngularModuleCall(node)) {
+        const requireDotNames = node.elements.map((element) => getRequireDotNameNode(element)).filter((x) => !!x);
+        requireDotNames.forEach(([_node, relativePath]) => {
+          const message = `Prefer 'import { ANGULARJS_MODULE } from "./module"' over 'require("./module").name'`;
+          const fix = getFixForRequireDotName(_node, context.getFilename(), relativePath);
+          context.report({ node: _node, message, fix });
+        });
+
+        const requireDotAnythings = node.elements
+          .map((element) => getRequireDotAnythingNode(element))
+          .filter((x) => !!x);
+        requireDotAnythings.forEach(([_node, requiredString, propertyName]) => {
+          const message = `Prefer 'import { default as ANGULARJS_MODULE } from "./module"' over 'require("./module").default'`;
+          const fix = getFixForRequireDotAnything(_node, requiredString, propertyName);
+          context.report({ node: _node, message, fix });
+        });
+
+        const bareRequires = node.elements.map((element) => getBareRequireNode(element)).filter((x) => !!x);
+        bareRequires.forEach(([_node, requiredString]) => {
+          const message = `Prefer 'import ANGULARJS_LIBRARY from "angularjs-library"' over 'require("angularjs-library")'`;
+          const fix = getFixForBareRequire(_node, requiredString);
+          context.report({ node: _node, message, fix });
+        });
+      }
+    },
+  };
+};
+
+/*
+Given:
+angular.module('module', [
+  require('angular-ui-bootstrap')
+]);
+
+Rewrites to:
+import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
+
+angular.module('module', [
+  ANGULAR_UI_BOOTSTRAP
+]);
+ */
+function getFixForBareRequire(node: Node, requiredString: string) {
+  return function (fixer: Rule.RuleFixer) {
+    const variableName = requiredString.replace(/[^\w_]/g, '_').toUpperCase();
+    const lastImport = findLastImportStatement(node);
+    const importStatement = `\nimport ${variableName} from '${requiredString}';`;
+    if (lastImport) {
+      return [fixer.replaceText(node, variableName), fixer.insertTextAfter(lastImport, importStatement)];
+    } else {
+      return [fixer.replaceText(node, variableName), fixer.insertTextBeforeRange([0, 0], importStatement)];
+    }
+  };
+}
+
+/*
+Given:
+angular.module('module', [
+  require('some/require/string').default
+]);
+
+Rewrites to:
+import { default as SOME_REQUIRE_STRING } from 'some/require/string';
+
+angular.module('module', [
+  SOME_REQUIRE_STRING
+]);
+ */
+function getFixForRequireDotAnything(node: Node, requiredString: string, property: string) {
+  return function (fixer: Rule.RuleFixer) {
+    const variableName = requiredString
+      .replace(/^[^\w_]*/g, '')
+      .replace(/[^\w_]/g, '_')
+      .toUpperCase();
+    const lastImport = findLastImportStatement(node);
+    const importStatement = `\nimport { ${property} as ${variableName} } from '${requiredString}';`;
+    if (lastImport) {
+      return [fixer.replaceText(node, variableName), fixer.insertTextAfter(lastImport, importStatement)];
+    } else {
+      return [fixer.replaceText(node, variableName), fixer.insertTextBeforeRange([0, 0], importStatement)];
+    }
+  };
+}
+
+/*
+Given:
+angular.module('module', [
+  require('./path/to/dependency').name
+]);
+
+Rewrites to:
+import { DEPENDENCY_SYMBOL } from './path/to/dependency';
+
+angular.module('module', [
+  DEPENDENCY_SYMBOL
+]);
+ */
+function getFixForRequireDotName(node: Node, filename: string, relativePath: string) {
+  const modulesPath = filename.replace(/modules\/.*/, 'modules/');
+
+  const path1 = path.resolve(filename, '..', relativePath);
+  const path2 = path.resolve(modulesPath, relativePath.replace(/^([a-zA-Z]+)\//, '$1/src/'));
+  const path3 = path.resolve(modulesPath, relativePath);
+
+  for (const path of [path1, path2, path3]) {
+    for (const extension of ['.ts', '.js']) {
+      if (fs.existsSync(path + extension)) {
+        const fileSource = fs.readFileSync(path + extension).toString();
+        const match = /export const name = ([\w_]*);/.exec(fileSource);
+        if (match) {
+          const variableName = match[1];
+          return function (fixer) {
+            const lastImport = findLastImportStatement(node);
+            const importStatement = `\nimport { ${variableName} } from '${relativePath}';`;
+            if (lastImport) {
+              return [fixer.replaceText(node, variableName), fixer.insertTextAfter(lastImport, importStatement)];
+            } else {
+              return [fixer.replaceText(node, variableName), fixer.insertTextBeforeRange([0, 0], importStatement)];
+            }
+          };
+        }
+      }
+    }
+  }
+}
+
+function findLastImportStatement(_node: Node) {
+  let program = _node as Rule.Node;
+  while (program && program.parent) {
+    program = program.parent;
+  }
+
+  if (program && program.type === 'Program') {
+    const imports = program.body.filter((node) => node.type === 'ImportDeclaration');
+    if (imports.length) {
+      return imports[imports.length - 1];
+    }
+  }
+}
+
+// require('./some/nested/angularjs/module').name
+function getRequireDotNameNode(node: Node): [Node, string] {
+  if (node.type !== 'MemberExpression') return undefined;
+  if (node.property.type !== 'Identifier' || node.property.name !== 'name') return undefined;
+  if (node.object.type !== 'CallExpression' || (node.object.callee as any).name !== 'require') return undefined;
+  if (node.object.arguments.length !== 1 || node.object.arguments[0].type !== 'Literal') return undefined;
+
+  // [node, './some/nested/angularjs/module']
+  return [node, node.object.arguments[0].value as string];
+}
+
+// require('something').anything
+function getRequireDotAnythingNode(node: Node): [Node, string, string] {
+  if (node.type !== 'MemberExpression') return undefined;
+  if (node.property.type !== 'Identifier') return undefined;
+  if (node.object.type !== 'CallExpression' || (node.object.callee as any).name !== 'require') return undefined;
+  if (node.object.arguments.length !== 1 || node.object.arguments[0].type !== 'Literal') return undefined;
+
+  // [node, 'something', 'anything']
+  return [node, node.object.arguments[0].value as string, node.property.name];
+}
+
+// require('something')
+function getBareRequireNode(node): [Node, string] {
+  if (node.type !== 'CallExpression' || node.callee.name !== 'require') return undefined;
+  if (node.arguments.length !== 1 || node.arguments[0].type !== 'Literal') return undefined;
+
+  // [node, 'something']
+  return [node, node.arguments[0].value as string];
+}
+
+function isInAngularModuleCall(arrayExpression) {
+  const { parent = {} } = arrayExpression;
+  if (parent.type === 'CallExpression') {
+    const { callee = {} } = parent;
+    const { type, object, property } = callee;
+    const isAngularModule =
+      type === 'MemberExpression' && object && object.name === 'angular' && property && property.name === 'module';
+    const isRawModule = type === 'Identifier' && callee.name === 'module';
+
+    return isAngularModule || isRawModule;
+  }
+  return false;
+}
+
+const ruleModule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Import an angular module name symbol instead of using require("../foo").name',
+    },
+    fixable: 'code',
+  },
+  create: rule,
+};
+
+export default ruleModule;

package/rules/ng-strictdi.spec.ts

@@ -0,0 +1,100 @@
+import rule from './ng-strictdi';
+import ruleTester from '../utils/ruleTester';
+ruleTester.run('ng-strictdi', rule, {
+  valid: [
+    {
+      code: `
+        import { module } from 'angular';
+        module('foo', [])
+          .directive('myDirective', ['$scope', function($scope) {}]);
+      `,
+    },
+    {
+      code: `
+        import { module } from 'angular';
+        class Controller {
+          static $inject = ['$scope'];
+          constructor($scope) {
+          }
+        }
+        module('foo', [])
+          .directive('myDirective', ['$scope', function($scope) {}]);
+      `,
+    },
+    {
+      code: `
+        import { module } from 'angular';
+        module('foo', [])
+          .directive('myDirective', ['$scope', function($scope) {}]);
+      `,
+    },
+  ],
+
+  invalid: [
+    {
+      errors: [{ message: 'The injected function has 1 parameter(s): ["$scope"], but no annotation was found' }],
+      code: `
+        const angular = require('angular');
+        angular.module('foo', [])
+          .controller('myController', function($scope) {});
+      `,
+      output: `
+        const angular = require('angular');
+        angular.module('foo', [])
+          .controller('myController', ['$scope', function($scope) {}]);
+      `,
+    },
+    {
+      errors: [
+        { message: 'The injected function \'MyClass\' has 1 parameter(s): ["$scope"], but no annotation was found' },
+      ],
+      code: `
+        import { module } from 'angular';
+        // Do not rename this to MyClassController or the checkDi rule will fire twice
+        class MyClass {
+          constructor($scope) {
+          }
+        }
+        module('foo', []).controller('myClassController', MyClass);
+      `,
+      output: `
+        import { module } from 'angular';
+        // Do not rename this to MyClassController or the checkDi rule will fire twice
+        class MyClass {
+          constructor($scope) {
+          }
+        }
+MyClass.$inject = ['$scope'];
+        module('foo', []).controller('myClassController', MyClass);
+      `,
+    },
+    {
+      errors: [{ message: 'The injected function has 1 parameter(s): ["$scope"], but no annotation was found' }],
+      code: `
+        const angular = require('angular');
+        angular.module('foo', [])
+          .directive('myDirective', { controller: function namedFunction($scope) {} });
+      `,
+      output: `
+        const angular = require('angular');
+        angular.module('foo', [])
+          .directive('myDirective', { controller: ['$scope', function namedFunction($scope) {}] });
+      `,
+    },
+    {
+      errors: [
+        { message: 'The injected function has 2 parameter(s): ["$scope","$location"], but no annotation was found' },
+      ],
+      code: `
+        const angular = require('angular');
+        angular.module('foo', [])
+          .directive('myDirective', { controller: function ($scope, $location) {} });
+      `,
+      output: `
+        const angular = require('angular');
+        angular.module('foo', [])
+          .directive('myDirective', { controller: ['$scope', '$location', function ($scope, $location) {}] });
+      `,
+    },
+  ],
+});

package/rules/ng-strictdi.ts

@@ -0,0 +1,304 @@
+/**
+ * require a consistent DI syntax
+ *
+ * All your DI should use the same syntax : the Array, function, or $inject syntaxes ("di":  [2, "array, function, or $inject"])
+ *
+ * @version 0.1.0
+ * @category conventions
+ * @sinceAngularVersion 1.x
+ */
+import type { Rule } from 'eslint';
+import { isEqual } from 'lodash';
+
+import angularRule from '../utils/angular-rule/angular-rule';
+import utils from '../utils/angular-rule/utils';
+
+const stripUnderscores = true;
+
+function normalizeParameter(param) {
+  return stripUnderscores ? param : param.replace(/^_(.+)_$/, (match, p1) => p1);
+}
+
+const rule = function (context: Rule.RuleContext) {
+  const $injectProperties = {};
+
+  function maybeNoteInjection(node) {
+    if (
+      node.left &&
+      node.left.property &&
+      ((utils.isLiteralType(node.left.property) && node.left.property.value === '$inject') ||
+        (utils.isIdentifierType(node.left.property) && node.left.property.name === '$inject'))
+    ) {
+      $injectProperties[node.left.object.name] = node.right;
+    }
+  }
+
+  function getDiStrings(name: string) {
+    const $inject = $injectProperties[name];
+    const elements = $inject && ($inject.elements || $inject.expression.elements);
+    return elements && elements.map((el) => el.value);
+  }
+
+  function compareParamsAndDI(node, name, type, context, params, diStrings) {
+    const paramNames = params.map((p) => normalizeParameter(p));
+    const diCount = diStrings ? diStrings.length : 0;
+    const paramCount = paramNames.length;
+
+    if (diCount === 0 && diCount !== paramCount) {
+      const message =
+        `The injected function${name ? ` '${name}'` : ''} ` +
+        `has ${paramCount} parameter(s): ${JSON.stringify(paramNames)}, ` +
+        `but no annotation was found`;
+
+      const injectStrings = params.map((p) => `'${p}'`).join(', ');
+
+      const fix = (fixer) => {
+        if (name && type === 'tsclass') {
+          return fixer.insertTextBefore(node, `public static $inject = [${injectStrings}];\n  `);
+        } else if (name && type === 'class') {
+          // find class node
+          let classNode = node;
+          while (classNode.type !== 'ClassDeclaration' && classNode.parent) {
+            classNode = classNode.parent;
+          }
+          return fixer.insertTextAfter(classNode, `\n${name}.$inject = [${injectStrings}];`);
+        } else if (name) {
+          return fixer.insertTextAfter(node, `\n${name}.$inject = [${injectStrings}];`);
+        } else {
+          return [fixer.insertTextBefore(node, `[${injectStrings}, `), fixer.insertTextAfter(node, `]`)];
+        }
+      };
+
+      // let program = node;
+      // while(program.parent) {program = program.parent}
+      // console.log(context.getSourceCode().getText(program));
+
+      context.report({ node, message, fix });
+    } else if (diCount !== paramCount) {
+      const message =
+        `The injected function${name ? ` '${name}'` : ''} ` +
+        `has ${paramCount} parameter(s): ${JSON.stringify(paramNames)}, ` +
+        `but there were ${diCount} DI strings${diCount === 0 ? '' : `: ${JSON.stringify(diStrings)} `}`;
+      context.report({ node, message });
+    } else if (!isEqual(diStrings, paramNames)) {
+      const message =
+        `The injected function${name ? ` '${name}'` : ''} ` +
+        `parameter names: ${JSON.stringify(paramNames)} ` +
+        `do not match the DI strings: ${JSON.stringify(diStrings)}`;
+      context.report({ node, message });
+    }
+  }
+
+  function fromArray(thisGuy) {
+    const { node, scope, callExpression } = thisGuy;
+    const args = node.elements.slice(0, -1);
+    const fn = node.elements.slice(-1)[0];
+    const diStrings = args.map((node) => node.value);
+
+    if (fn.type === 'Identifier') {
+      const name = fn.name;
+      const result = fromIdentifier({ node: fn, scope, callExpression });
+      const params = result.fn.params && result.fn.params.map((param) => param.name);
+      return { type: 'array', fn: result.fn, name, params, diStrings };
+    }
+
+    const params = fn.params && fn.params.map((param) => param.name);
+    return { type: 'array', fn, name: undefined, params, diStrings };
+  }
+
+  function fromIdentifier(thisGuy) {
+    const { node, scope } = thisGuy;
+    const reference = scope.references.find((r) => r.identifier.name === node.name);
+    const resolved = reference && reference.resolved;
+    if (resolved) {
+      const { defs, scope: resolvedScope } = resolved;
+      return processThisGuy({ node: defs[0].node, scope: resolvedScope });
+    }
+  }
+
+  function fromVariableDeclarator(thisGuy) {
+    const { node, scope } = thisGuy;
+    const { name } = node.id;
+    const fn = node.init;
+
+    const variable = scope.variables.find((v) => v.name === name);
+
+    if (!variable) {
+      throw new Error(`Weird, I couldn't find variable '${name}' in scope?`);
+    }
+
+    if (variable.defs.length > 1) {
+      throw new Error('It is pretty unexpected to find more than one def in this guys variable?');
+    }
+
+    const params = fn.params.map((param) => param.name);
+    const diStrings = getDiStrings(name);
+
+    // TODO: is this really function?
+    return { type: 'function', fn, name, params, diStrings };
+  }
+
+  function fromClassDeclaration(thisGuy) {
+    const { node } = thisGuy;
+    const { name } = node.id;
+    const ctor = node.body.body.find((node) => node.type === 'MethodDefinition' && node.kind === 'constructor');
+    if (!ctor) return null;
+    const isTypescript = !!context.getFilename().match(/\.tsx?$/);
+    const params = ctor.value.params.map((param) =>
+      param.type === 'TSParameterProperty' ? param.parameter.name : param.name,
+    );
+    const $inject = node.body.body.find(
+      (node) => node.type === 'ClassProperty' && node.static && node.key.name === '$inject',
+    );
+    const diStrings = $inject ? $inject.value.elements.map((el) => el.value) : getDiStrings(name);
+    return { type: isTypescript ? 'tsclass' : 'class', fn: ctor, name, params, diStrings };
+  }
+
+  function fromFunction(thisGuy) {
+    const { node: fn } = thisGuy;
+    const name = fn.type === 'FunctionDeclaration' ? fn.id.name : fn.name;
+    const params = fn.params.map((param) => param.name);
+    const diStrings = getDiStrings(name);
+    return { type: 'function', fn, name, params, diStrings };
+  }
+
+  function processThisGuy(thisGuy) {
+    if (!thisGuy || !thisGuy.node) {
+      throw new Error('processThisGuy: Unexpected null argument');
+    }
+
+    switch (thisGuy.node.type) {
+      case 'ArrayExpression':
+        return fromArray(thisGuy);
+      case 'ArrowFunctionExpression':
+      case 'FunctionExpression':
+      case 'FunctionDeclaration':
+        return fromFunction(thisGuy);
+      case 'Identifier':
+        return fromIdentifier(thisGuy);
+      case 'VariableDeclarator':
+        return fromVariableDeclarator(thisGuy);
+      case 'ClassDeclaration':
+        return fromClassDeclaration(thisGuy);
+      case 'MemberExpression': {
+        const memberExpression = context.getSourceCode().getText(thisGuy.node);
+        // allowlist some known symbols
+        if (!['angular.noop', 'noop'].includes(memberExpression)) {
+          console.warn(`Unable to handle MemberExpression: ${memberExpression}`);
+        }
+        return null;
+      }
+      case 'ImportSpecifier': {
+        // const importSpecifier = context.getSourceCode().getText(thisGuy.node);
+        // console.warn(`warn: Unable to handle ImportSpecifier: ${importSpecifier} in ${context.getFilename()}`);
+        return null;
+      }
+      default:
+        console.error(context.getSourceCode().getText(thisGuy.node));
+        throw new Error(`Unknown type: ${thisGuy.node.type}`);
+    }
+  }
+
+  function checkDi(callee, thisGuy) {
+    if (!thisGuy) {
+      throw new Error('checkDi: unexpected null argument');
+    } else if (!thisGuy.node) {
+      throw new Error('checkDi: missing node in thisGuy');
+    }
+
+    let result;
+    try {
+      result = processThisGuy(thisGuy);
+    } catch (error) {
+      console.error(`Internal error while processing ${context.getFilename()}`);
+      console.error(context.getSourceCode().getText(thisGuy.callExpression));
+      throw error;
+    }
+    if (!result) return;
+    const { type, fn, name, params, diStrings } = result;
+
+    // If there's an array, validate it
+    if (type === 'array') {
+      const expectedTypes = ['ArrowFunctionExpression', 'FunctionExpression', 'FunctionDeclaration'];
+      if (!expectedTypes.includes(fn.type)) {
+        const message = `Array-style: The last element should be an injected function, but it was: ${fn.type}`;
+        return context.report({ node: fn, message });
+      }
+
+      if (!diStrings.every((str) => typeof str === 'string')) {
+        return context.report({ node: fn, message: `Array-style: Elements [0..n-2] should all be strings` });
+      }
+    }
+
+    if (params.length) {
+      compareParamsAndDI(fn, name, type, context, params, diStrings);
+    }
+  }
+
+  return {
+    'angular?animation': checkDi,
+    'angular?config': checkDi,
+    'angular?controller': checkDi,
+    'angular?component': function (callee, thisGuy) {
+      if (thisGuy.node.type === 'ObjectExpression') {
+        const property = thisGuy.node.properties.find((prop) => prop.key.name === 'controller');
+        if (property) {
+          if (property.value.type !== 'Literal') {
+            return checkDi(callee, Object.assign({}, thisGuy, { node: property.value }));
+          }
+        }
+      }
+    },
+    'angular?decorator': checkDi,
+    'angular?directive': function (callee, thisGuy) {
+      if (thisGuy.node.type === 'ObjectExpression') {
+        const property = thisGuy.node.properties.find((prop) => prop.key.name === 'controller');
+        if (property) {
+          if (property.value.type !== 'Literal') {
+            return checkDi(callee, Object.assign({}, thisGuy, { node: property.value }));
+          }
+        }
+      }
+    },
+    'angular?factory': checkDi,
+    'angular?filter': checkDi,
+    'angular?inject': checkDi,
+    'angular?run': checkDi,
+    'angular?service': checkDi,
+    'angular?provider': function (callee, providerFn, $get) {
+      checkDi(null, providerFn);
+      checkDi(null, $get);
+    },
+    'CallExpression:exit': function (node) {
+      const { object, property } = node.callee;
+      if (object && object.name === '$provide' && property && property.name === 'decorator') {
+        checkDi(null, { node: node.arguments[1], scope: context.getScope() });
+      }
+    },
+    AssignmentExpression: function (node) {
+      maybeNoteInjection(node);
+    },
+    ClassDeclaration: function (node) {
+      const interfaces = ['IController', 'ng.IController'];
+      const implementsIController = (node.implements || []).some((impl) => interfaces.includes(impl.expression.name));
+      const isNamedSortaLikeOne = node.id.name.match(/(Ctrl|Controller)$/);
+      const isClassController = implementsIController || isNamedSortaLikeOne;
+
+      if (isClassController) {
+        checkDi(null, { node: node });
+      }
+    },
+  };
+};
+
+const ruleModule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'All angularjs functions must be explicitly annotated',
+    },
+    fixable: 'code',
+  },
+  create: angularRule(rule),
+};
+export default ruleModule;

package/rules/prefer-promise-like.spec.ts

@@ -0,0 +1,75 @@
+import rule from './prefer-promise-like';
+import ruleTester from '../utils/ruleTester';
+const errorMessage = `Prefer using PromiseLike type instead of AngularJS IPromise.`;
+const unusedImportErrorMessage = `Unused IPromise import`;
+
+ruleTester.run('prefer-promise-like', rule, {
+  valid: [
+    {
+      code: `const foo: PromiseLike<any> = API.one('foo', 'bar').get();`,
+    },
+  ],
+
+  invalid: [
+    // IPromise in variable
+    {
+      code: `const foo: IPromise<any> = API.one('foo', 'bar').get();`,
+      output: `const foo: PromiseLike<any> = API.one('foo', 'bar').get();`,
+      errors: [errorMessage],
+    },
+    // IPromise in function arg
+    {
+      code: `function foo(promise: IPromise<any>) {}`,
+      output: `function foo(promise: PromiseLike<any>) {}`,
+      errors: [errorMessage],
+    },
+    // IPromise in class method return
+    {
+      code: `class Foo { foo(): IPromise<any> {} }`,
+      output: `class Foo { foo(): PromiseLike<any> {} }`,
+      errors: [errorMessage],
+    },
+    // ng.IPromise in variable
+    {
+      code: `const foo: ng.IPromise<any> = API.one('foo', 'bar').get();`,
+      output: `const foo: PromiseLike<any> = API.one('foo', 'bar').get();`,
+      errors: [errorMessage],
+    },
+    // ng.IPromise in function arg
+    {
+      code: `function foo(promise: ng.IPromise<any>) {}`,
+      output: `function foo(promise: PromiseLike<any>) {}`,
+      errors: [errorMessage],
+    },
+    // ng.IPromise in class method return
+    {
+      code: `class Foo { foo(): ng.IPromise<any> {} }`,
+      output: `class Foo { foo(): PromiseLike<any> {} }`,
+      errors: [errorMessage],
+    },
+    // Unused IPromise import
+    {
+      code: `import { IPromise } from 'angular';`,
+      output: ``,
+      errors: [unusedImportErrorMessage],
+    },
+    // Unused IPromise import 2
+    {
+      code: `import { module, IPromise } from 'angular';`,
+      output: `import { module } from 'angular';`,
+      errors: [unusedImportErrorMessage],
+    },
+    // Unused IPromise import 3
+    {
+      code: `import { IPromise, module } from 'angular';`,
+      output: `import { module } from 'angular';`,
+      errors: [unusedImportErrorMessage],
+    },
+    // Unused IPromise import 4
+    {
+      code: `import { QService, IPromise, module } from 'angular';`,
+      output: `import { QService, module } from 'angular';`,
+      errors: [unusedImportErrorMessage],
+    },
+  ],
+});