docs(types): fix typings in tests

Author: Gvozd

__mocks__/node-notifier.ts

@@ -1 +1 @@
-export const notify = jest.fn(() => void 0);
+export const notify: jest.Mock = jest.fn(() => void 0);

index.d.ts

@@ -3,6 +3,7 @@
 // Definitions by: Benjamin Lim <https://github.com/bumbleblym>
 //                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
 //                 Alexandre Germain <https://github.com/gerkindev>
+//                 Gvozdev Viktor <https://github.com/Gvozd>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 3.9
 
@@ -14,18 +15,20 @@ declare const WebpackNotifierPlugin: {new (options?: WebpackNotifierPlugin.Optio
 
 declare namespace WebpackNotifierPlugin {
     interface Options {
-        alwaysNotify?: boolean | undefined;
-        contentImage?: {[key in 'success' | 'warning' | 'error']: string} | string | undefined;
-        excludeWarnings?: boolean | undefined;
-        onlyOnError?: boolean | undefined;
-        skipFirstNotification?: boolean | undefined;
-        title?: string | undefined;
+        alwaysNotify?: boolean;
+        contentImage?: {[key in 'success' | 'warning' | 'error']: string} | string;
+        excludeWarnings?: boolean;
+        onlyOnError?: boolean;
+        skipFirstNotification?: boolean;
+        title?: string | TitleGetter;
         /**
          * Use emoji in notifications
          */
-        emoji?: boolean | undefined;
+        emoji?: boolean;
     }
 
     /** @deprecated use Options */
     type Config = Options;
+
+    type TitleGetter = (data: {msg: string,message: string,status: string}) => string;
 }

package.json

@@ -41,6 +41,8 @@
   },
   "devDependencies": {
     "@types/jest": "^26.0.15",
+    "@types/node-notifier": "^8.0.1",
+    "@types/semver": "^7.3.8",
     "@types/webpack": "^4.41.31",
     "eslint": "^7.14.0",
     "eslint-config-airbnb-base": "^14.2.1",

test-d/index-tests.ts

@@ -10,6 +10,9 @@ const optionsArray: WebpackNotifierPlugin.Options[] = [
 		skipFirstNotification: true,
 		emoji: true,
 	},
+	{
+		title: (data: {msg: string,message: string,status: string}) => 'Webpack',
+	},
 ];
 
 const plugins: Plugin[] = optionsArray.map(options => new WebpackNotifierPlugin(options));

test/VerbosityLevelAllVariants.test.ts

@@ -1,3 +1,4 @@
+import WebpackNotifierPlugin from '../';
 import {contentImageSerializer, reduceArraySerializer, testChangesFlow} from './helpers/utils';
 
 expect.addSnapshotSerializer(reduceArraySerializer);
@@ -8,7 +9,7 @@ describe('VerbosityLevelAllVariants', () => {
     test.each([...generateSteps(opts)])('%j', testChangesFlow);
   });
 
-  function* generateOptions() {
+  function* generateOptions(): Generator<WebpackNotifierPlugin.Options> {
     for (const excludeWarnings of [false, true]) {
       for (const alwaysNotify of [false, true]) {
         for (const onlyOnError of [false, true]) {
@@ -19,7 +20,7 @@ describe('VerbosityLevelAllVariants', () => {
       }
     }
   }
-  function* generateSteps(opts) {
+  function* generateSteps(opts: WebpackNotifierPlugin.Options): Generator<[string[], WebpackNotifierPlugin.Options]> {
     for (const firsStep of ['successful', 'warning', 'error']) {
       yield [[firsStep], opts];
       for (const secondStep of ['successful', 'warning', 'error']) {

test/WebpackNotifierPlugin.test.ts

@@ -21,7 +21,7 @@ describe('WebpackNotifierPlugin', () => {
       [['error'], {title}],
       [['warning'], {title}],
     ])('%j %j', testChangesFlow);
-    function title({msg}) {
+    function title({msg}: {msg: string}) {
       if (msg.startsWith('Error')) return 'build error ❌';
       if (msg.startsWith('Warning')) return 'build warning ⚠️';
       return 'build complete ✅';
@@ -33,7 +33,7 @@ describe('WebpackNotifierPlugin', () => {
         [['error'], {title}],
         [['warning'], {title}],
       ])('%j %j', testChangesFlow);
-      function title(params) {
+      function title(params: {status: string, message: string}) {
         return `Build status is ${params.status} with message ${params.message}`;
       }
     });

test/helpers/ChildCompilationPlugin.ts

@@ -1,3 +1,4 @@
+import {Compiler} from 'webpack';
 export default class ChildCompilationPlugin {
   private levelCollectionKey: string;
 
@@ -7,19 +8,19 @@ export default class ChildCompilationPlugin {
     }
   }
 
-  apply(compiler) {
+  apply(compiler: Compiler) {
     if ('hooks' in compiler) {
       compiler.hooks.thisCompilation.tap('ChildCompilationPlugin', this.handleHook.bind(this));
     } else {
-      compiler.plugin('this-compilation', this.handleHook.bind(this));
+      (compiler as any).plugin('this-compilation', this.handleHook.bind(this));
     }
   }
 
-  handleHook(compilation) {
-    const childCompiler = compilation.createChildCompiler(`CHILD COMPILATION`);
-    childCompiler.runAsChild((err, entries, compilation) => {
+  handleHook(compilation: any) {
+    const childCompiler = (compilation as any).createChildCompiler(`CHILD COMPILATION`);
+    childCompiler.runAsChild((err: Error, entries: any, compilation: any) => {
       if (this.level) {
-        compilation[this.levelCollectionKey]
+        (compilation as any)[this.levelCollectionKey]
           .push(new Error(`Child Compilation ${this.level}`));
       }
     });

test/helpers/CustomWarningPlugin.ts

@@ -1,15 +1,17 @@
+import {Compiler} from 'webpack';
 export default class CustomWarningPlugin {
-  apply(compiler) {
+  apply(compiler: Compiler) {
     if ('hooks' in compiler) {
       compiler.hooks.shouldEmit.tap('CustomWarningPlugin', this.handleHook);
     } else {
-      compiler.plugin('should-emit', this.handleHook);
+      (compiler as any).plugin('should-emit', this.handleHook);
     }
   }
-  handleHook(compilation) {
-    compilation.warnings.push(Object.assign(
+  handleHook(compilation: any) {
+    (compilation.warnings as Error[]).push(Object.assign(
       new Error('Custom Warning'),
       {warning: 'Custom Warning message'}
     ));
+    return false;
   }
 };

test/helpers/utils.ts

@@ -5,10 +5,10 @@ import {createFsFromVolume, Volume} from 'memfs';
 import {notify} from 'node-notifier';
 import {satisfies} from 'semver';
 import fixtures from './fixtures';
-import WebpackNotifierPlugin from '../../';
+import WebpackNotifierPlugin, {Options} from '../../';
 
-function getCompiler(compilerOpts) {
-  const config = {
+function getCompiler(compilerOpts: webpack.Configuration): webpack.Compiler {
+  const config: webpack.Configuration = {
     entry: '/entry.js',
     output: {
       path: '/',
@@ -22,20 +22,20 @@ function getCompiler(compilerOpts) {
 
   return webpack(config);
 }
-function patchCompiler(compiler, fs) {
+function patchCompiler(compiler: webpack.Compiler, fs: any) {
   compiler.inputFileSystem = fs;
   compiler.outputFileSystem = fs;
   // compiler.watchFileSystem = fs;
 
   if (satisfies(webpackVersion, '<5')) {
-    compiler['resolvers'].normal.fileSystem = fs;
+    (compiler as any)['resolvers'].normal.fileSystem = fs;
     // compiler['resolvers'].loader.fileSystem = fs;
     // compiler['resolvers'].context.fileSystem = fs;
   }
 }
-async function compile(compiler) {
+async function compile(compiler: webpack.Compiler): Promise<webpack.Stats> {
   return new Promise((resolve, reject) => {
-    compiler.run((err, res) => {
+    compiler.run((err?: Error, res?: webpack.Stats) => {
       if (err) {
         return reject(err);
       }
@@ -49,18 +49,18 @@ function prepareFs() {
   const fs = createFsFromVolume(vol);
 
   if (satisfies(webpackVersion, '<5')) {
-    fs['join'] = join;
+    (fs as any)['join'] = join;
   }
 
   return {fs, vol};
 }
 
-function updateFs(vol, json) {
+function updateFs(vol: any, json: any) {
   vol.reset();
   vol.fromJSON(json, '/');
 }
 
-export const reduceArraySerializer = {
+export const reduceArraySerializer: jest.SnapshotSerializerPlugin = {
   test(val) {
     return Array.isArray(val) &&
       val.length === 1 &&
@@ -73,7 +73,7 @@ export const reduceArraySerializer = {
     return printer(val[0][0], config, indentation, depth, refs);
   },
 };
-export const contentImageSerializer = {
+export const contentImageSerializer: jest.SnapshotSerializerPlugin = {
   test(val) {
     return typeof val === 'object' &&
       val.contentImage &&
@@ -90,7 +90,7 @@ export const contentImageSerializer = {
 };
 
 export type Sources = string[];
-export type PluginOptions = {} | undefined;
+export type PluginOptions = Options | undefined;
 export type CompilerOptions = {};
 export type TestArguments = [Sources, PluginOptions, CompilerOptions?];
 
@@ -99,17 +99,17 @@ export function testChangesFlow(...args: TestArguments)  {
   return runTest(...args);
 };
 
-async function runTest(sources, opts, compilerOpts = {})  {
+async function runTest(sources: Sources, opts: PluginOptions, compilerOpts = {})  {
   const compiler = getCompiler(compilerOpts);
   const {fs, vol} = prepareFs();
   const plugin = new WebpackNotifierPlugin(opts);
   plugin.apply(compiler);
   patchCompiler(compiler, fs);
 
   for (const name of sources) {
-    notify.mockClear();
-    updateFs(vol, fixtures.simple[name]);
+    (notify as jest.Mock).mockClear();
+    updateFs(vol, (fixtures.simple as any)[name]);
     await compile(compiler);
-    expect(notify.mock.calls).toMatchSnapshot(`after "${name}" build`);
+    expect((notify as jest.Mock).mock.calls).toMatchSnapshot(`after "${name}" build`);
   }
 }

tsconfig.json

@@ -3,5 +3,9 @@
     "esModuleInterop": true,
     "resolveJsonModule": true,
     "downlevelIteration": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true
   }
 }