Haraka 2.8.28 → 3.0.1

package/smtp_client.js

@@ -11,7 +11,6 @@
 const events       = require('events');
 
 // npm deps
-const generic_pool = require('generic-pool');
 const ipaddr       = require('ipaddr.js');
 const net_utils    = require('haraka-net-utils');
 const utils        = require('haraka-utils');
@@ -21,7 +20,7 @@ const line_socket = require('./line_socket');
 const logger      = require('./logger');
 const HostPool    = require('./host_pool');
 
-const smtp_regexp = /^([0-9]{3})([ -])(.*)/;
+const smtp_regexp = /^(\d{3})([ -])(.*)/;
 const STATE = {
     IDLE: 1,
     ACTIVE: 2,
@@ -30,11 +29,11 @@ const STATE = {
 }
 
 class SMTPClient extends events.EventEmitter {
-    constructor (port, host, connect_timeout, idle_timeout, socket) {
+    constructor (opts = {}) {
         super();
         this.uuid = utils.uuid();
-        this.connect_timeout = parseInt(connect_timeout) || 30;
-        this.socket = socket || line_socket.connect(port, host);
+        this.connect_timeout = parseInt(opts.connect_timeout) || 30;
+        this.socket = opts.socket || line_socket.connect(opts.port, opts.host);
         this.socket.setTimeout(this.connect_timeout * 1000);
         this.socket.setKeepAlive(true);
         this.state = STATE.IDLE;
@@ -44,8 +43,8 @@ class SMTPClient extends events.EventEmitter {
         this.authenticating= false;
         this.authenticated = false;
         this.auth_capabilities = [];
-        this.host = host;
-        this.port = port;
+        this.host = opts.host;
+        this.port = opts.port;
         this.smtputf8 = false;
 
         const client = this;
@@ -68,7 +67,10 @@ class SMTPClient extends events.EventEmitter {
 
             if (client.command === 'auth' || client.authenticating) {
                 logger.loginfo(`SERVER RESPONSE, CLIENT ${client.command}, authenticating=${client.authenticating},code=${code},cont=${cont},msg=${msg}`);
-                if (/^3/.test(code) && msg === 'VXNlcm5hbWU6') {
+                if (/^3/.test(code) && (
+                    msg === 'VXNlcm5hbWU6' ||
+                    msg === 'dXNlcm5hbWU6' // Workaround ill-mannered SMTP servers (namely smtp.163.com)
+                )) {
                     client.emit('auth_username');
                     return;
                 }
@@ -150,7 +152,7 @@ class SMTPClient extends events.EventEmitter {
 
         client.socket.on('connect', () => {
             // Replace connection timeout with idle timeout
-            client.socket.setTimeout((idle_timeout || 300) * 1000);
+            client.socket.setTimeout((opts.idle_timeout || 300) * 1000);
             if (!client.socket.remoteAddress) {
                 // "Value may be undefined if the socket is destroyed"
                 logger.logdebug('socket.remoteAddress undefined');
@@ -161,28 +163,28 @@ class SMTPClient extends events.EventEmitter {
 
         function closed (msg) {
             return error => {
-                if (!error) {
-                    error = '';
-                }
-                // msg is e.g. "errored" or "timed out"
+                if (!error) error = '';
+
                 // error is e.g. "Error: connect ECONNREFUSED"
                 const errMsg = `${client.uuid}: [${client.host}:${client.port}] SMTP connection ${msg} ${error}`;
-                if (client.state === STATE.ACTIVE) {
-                    client.emit('error', errMsg);
-                }
+
+                /* eslint-disable no-fallthrough */
                 switch (client.state) {
                     case STATE.ACTIVE:
+                        client.emit('error', errMsg);
                     case STATE.IDLE:
                     case STATE.RELEASED:
                         client.destroy();
                         break;
+                    case STATE.DESTROYED:
+                        if (msg === 'errored' || msg === 'timed out') {
+                            client.emit('connection-error', errMsg);
+                        }
+                        break
                     default:
                 }
-                if ((msg === 'errored' || msg === 'timed out') && client.state === STATE.DESTROYED) {
-                    client.emit('connection-error', errMsg);
-                } // don't return, continue (original behavior)
 
-                logger.logdebug(`[smtp_client_pool] ${errMsg} (state=${client.state})`);
+                logger.logdebug(`[smtp_client] ${errMsg} (state=${client.state})`);
             }
         }
 
@@ -217,17 +219,8 @@ class SMTPClient extends events.EventEmitter {
     }
 
     release () {
-        if (!this.connected || this.command === 'data' || this.command === 'mailbody') {
-            // Destroy here, we can't reuse a connection that was mid-data.
-            this.destroy();
-            return;
-        }
-
-        logger.logdebug(`[smtp_client_pool] ${this.uuid} resetting, state=${this.state}`);
-        if (this.state === STATE.DESTROYED) {
-            return;
-        }
-        this.state = STATE.RELEASED;
+        if (this.state === STATE.DESTROYED) return;
+        logger.logdebug(`[smtp_client] ${this.uuid} releasing, state=${this.state}`);
 
         [
             'auth',   'bad_code', 'capabilities', 'client_protocol', 'connection-error',
@@ -237,47 +230,33 @@ class SMTPClient extends events.EventEmitter {
             this.removeAllListeners(l);
         })
 
-        this.on('bad_code', (code, msg) => {
-            this.destroy();
-        });
-
-        this.on('rset', () => {
-            logger.logdebug(`[smtp_client_pool] ${this.uuid} releasing, state=${this.state}`);
-            if (this.state === STATE.DESTROYED) return;
-
-            this.state = STATE.IDLE;
-            this.removeAllListeners('rset');
-            this.removeAllListeners('bad_code');
-            this.pool.release(this);
-        });
-
-        this.send_command('RSET');
+        if (this.connected) this.send_command('QUIT');
+        this.destroy()
     }
 
     destroy () {
-        if (this.state !== STATE.DESTROYED) {
-            this.pool.destroy(this);
-        }
+        if (this.state === STATE.DESTROYED) return
+        this.state = STATE.DESTROYED;
+        this.socket.destroy();
     }
 
     upgrade (tls_options) {
-        const this_logger = logger;
 
         this.socket.upgrade(tls_options, (verified, verifyError, cert, cipher) => {
-            this_logger.loginfo(`secured:${
+            logger.loginfo(`secured:${
+
                 (cipher) ? ` cipher=${cipher.name} version=${cipher.version}` : ''
             } verified=${verified}${
                 (verifyError) ? ` error="${verifyError}"` : ''
-            }${(cert && cert.subject) ? ` cn="${cert.subject.CN}" organization="${cert.subject.O}"` : ''
-            }${(cert && cert.issuer) ? ` issuer="${cert.issuer.O}"` : ''
-            }${(cert && cert.valid_to) ? ` expires="${cert.valid_to}"` : ''
-            }${(cert && cert.fingerprint) ? ` fingerprint=${cert.fingerprint}` : ''}`);
+            }${(cert?.subject) ? ` cn="${cert.subject.CN}" organization="${cert.subject.O}"` : ''
+            }${(cert?.issuer) ? ` issuer="${cert.issuer.O}"` : ''
+            }${(cert?.valid_to) ? ` expires="${cert.valid_to}"` : ''
+            }${(cert?.fingerprint) ? ` fingerprint=${cert.fingerprint}` : ''}`);
         });
     }
 
-
     is_dead_sender (plugin, connection) {
-        if (connection.transaction) return false;
+        if (connection?.transaction) return false;
 
         // This likely means the sender went away on us, cleanup.
         connection.logwarn(plugin, "transaction went away, releasing smtp_client");
@@ -288,64 +267,14 @@ class SMTPClient extends events.EventEmitter {
 
 exports.smtp_client = SMTPClient;
 
-// Separate pools are kept for each set of server attributes.
-exports.get_pool = (server, port, host, cfg) => {
-    port = port || 25;
-    host = host || 'localhost';
-    if (cfg === undefined) cfg = {};
-    const connect_timeout = cfg.connect_timeout || 30;
-    const pool_timeout = cfg.pool_timeout || cfg.timeout || 300;
-    const auth_user = cfg.auth_user || 'no_user';
-    const name = `${port}:${host}:${pool_timeout}:${auth_user}`;
-    if (!server.notes.pool) server.notes.pool = {};
-    if (server.notes.pool[name]) return server.notes.pool[name];
-
-    const pool = generic_pool.Pool({
-        name,
-        create: callback => {
-            const smtp_client = new SMTPClient(port, host, connect_timeout, pool_timeout);
-            logger.logdebug(`[smtp_client_pool] uuid=${smtp_client.uuid} host=${host}` +
-                ` port=${port} pool_timeout=${pool_timeout} created`);
-            callback(null, smtp_client);
-        },
-        destroy: smtp_client => {
-            logger.logdebug(`[smtp_client_pool] ${smtp_client.uuid} destroyed, state={smtp_client.state}`);
-            smtp_client.state = STATE.DESTROYED;
-            smtp_client.socket.destroy();
-            // Remove pool object from server notes once empty
-            const size = pool.getPoolSize();
-            if (size === 0) {
-                delete server.notes.pool[name];
-            }
-        },
-        max: cfg.max_connections || 1000,
-        idleTimeoutMillis: (pool_timeout - 1) * 1000,
-        log: (str, level) => {
-            level = (level === 'verbose') ? 'debug' : level;
-            logger[`log${level}`](`[smtp_client_pool] [${name}] ${str}`);
-        }
-    });
-
-    const acquire = pool.acquire;
-    pool.acquire = (callback, priority) => {
-        function callback_wrapper (err, smtp_client) {
-            smtp_client.pool = pool;
-            smtp_client.state = STATE.ACTIVE;
-            callback(err, smtp_client);
-        }
-        acquire.call(pool, callback_wrapper, priority);
-    };
-    server.notes.pool[name] = pool;
-    return pool;
-}
-
 // Get a smtp_client for the given attributes.
-exports.get_client = (server, callback, port, host, cfg) => {
-    const pool = exports.get_pool(server, port, host, cfg);
-    pool.acquire(callback);
+// used only in testing
+exports.get_client = (server, callback, opts = {}) => {
+    const smtp_client = new SMTPClient(opts)
+    logger.logdebug(`[smtp_client] uuid=${smtp_client.uuid} host=${opts.host} port=${opts.port} created`)
+    callback(smtp_client)
 }
 
-
 exports.onCapabilitiesOutbound = (smtp_client, secured, connection, config, on_secured) => {
     for (const line in smtp_client.response) {
         if (/^XCLIENT/.test(smtp_client.response[line])) {
@@ -383,8 +312,8 @@ exports.onCapabilitiesOutbound = (smtp_client, secured, connection, config, on_s
         if (auth_matches) {
             smtp_client.auth_capabilities = [];
             auth_matches = auth_matches[1].split(' ');
-            for (let i = 0; i < auth_matches.length; i++) {
-                smtp_client.auth_capabilities.push(auth_matches[i].toLowerCase());
+            for (const authMatch of auth_matches) {
+                smtp_client.auth_capabilities.push(authMatch.toLowerCase());
             }
         }
     }
@@ -406,122 +335,119 @@ exports.get_client_plugin = (plugin, connection, c, callback) => {
     }
 
     const hostport = get_hostport(connection, connection.server, c);
+    const smtp_client = new SMTPClient(hostport)
+    logger.loginfo(`[smtp_client] uuid=${smtp_client.uuid} host=${hostport.host} port=${hostport.port} created`);
 
-    const pool = exports.get_pool(connection.server, hostport.port, hostport.host, c);
+    connection.logdebug(plugin, `Got smtp_client: ${smtp_client.uuid}`);
 
-    pool.acquire((err, smtp_client) => {
-        connection.logdebug(plugin, `Got smtp_client: ${smtp_client.uuid}`);
+    let secured = false;
 
-        let secured = false;
+    smtp_client.load_tls_config(plugin.tls_options);
 
-        smtp_client.load_tls_config(plugin.tls_options);
-
-        smtp_client.call_next = function (retval, msg) {
-            if (this.next) {
-                const next = this.next;
-                delete this.next;
-                next(retval, msg);
-            }
+    smtp_client.call_next = function (retval, msg) {
+        if (this.next) {
+            const { next } = this;
+            delete this.next;
+            next(retval, msg);
         }
+    }
 
-        smtp_client.on('client_protocol', (line) => {
-            connection.logprotocol(plugin, `C: ${line}`);
-        })
+    smtp_client.on('client_protocol', (line) => {
+        connection.logprotocol(plugin, `C: ${line}`);
+    })
 
-        smtp_client.on('server_protocol', (line) => {
-            connection.logprotocol(plugin, `S: ${line}`);
-        })
+    smtp_client.on('server_protocol', (line) => {
+        connection.logprotocol(plugin, `S: ${line}`);
+    })
 
-        function helo (command) {
-            if (smtp_client.xclient) {
-                smtp_client.send_command(command, connection.hello.host);
-            }
-            else {
-                smtp_client.send_command(command, connection.local.host);
-            }
+    function helo (command) {
+        if (smtp_client.xclient) {
+            smtp_client.send_command(command, connection.hello.host);
         }
-        smtp_client.on('greeting', helo);
-        smtp_client.on('xclient', helo);
-
-        function on_secured () {
-            secured = true;
-            smtp_client.secured = true;
-            smtp_client.emit('greeting', 'EHLO');
+        else {
+            smtp_client.send_command(command, connection.local.host);
         }
+    }
+    smtp_client.on('greeting', helo);
+    smtp_client.on('xclient', helo);
+
+    function on_secured () {
+        if (secured) return;
+        secured = true;
+        smtp_client.secured = true;
+        smtp_client.emit('greeting', 'EHLO');
+    }
 
-        smtp_client.on('capabilities', () => {
-            exports.onCapabilitiesOutbound(smtp_client, secured, connection, c, on_secured);
-        });
+    smtp_client.on('capabilities', () => {
+        exports.onCapabilitiesOutbound(smtp_client, secured, connection, c, on_secured);
+    });
 
-        smtp_client.on('helo', () => {
-            if (!c.auth || smtp_client.authenticated) {
-                if (smtp_client.is_dead_sender(plugin, connection)) {
-                    return;
-                }
-                smtp_client.send_command('MAIL', `FROM:${connection.transaction.mail_from.format(!smtp_client.smtp_utf8)}`);
-                return;
-            }
+    smtp_client.on('helo', () => {
+        if (!c.auth || smtp_client.authenticated) {
+            if (smtp_client.is_dead_sender(plugin, connection)) return;
 
-            if (c.auth.type === null || typeof (c.auth.type) === 'undefined') return; // Ignore blank
-            const auth_type = c.auth.type.toLowerCase();
-            if (!smtp_client.auth_capabilities.includes(auth_type)) {
-                throw new Error(`Auth type "${auth_type}" not supported by server (supports: ${smtp_client.auth_capabilities.join(',')})`);
-            }
-            switch (auth_type) {
-                case 'plain':
-                    if (!c.auth.user || !c.auth.pass) {
-                        throw new Error("Must include auth.user and auth.pass for PLAIN auth.");
-                    }
-                    logger.logdebug(`[smtp_client_pool] uuid=${smtp_client.uuid} authenticating as "${c.auth.user}"`);
-                    smtp_client.send_command('AUTH',
-                        `PLAIN ${utils.base64(`${c.auth.user}\0${c.auth.user}\0${c.auth.pass}`)}`);
-                    break;
-                case 'cram-md5':
-                    throw new Error("Not implemented");
-                default:
-                    throw new Error(`Unknown AUTH type: ${auth_type}`);
-            }
-        });
+            smtp_client.send_command('MAIL', `FROM:${connection.transaction.mail_from.format(!smtp_client.smtp_utf8)}`);
+            return;
+        }
+
+        if (c.auth.type === null || typeof (c.auth.type) === 'undefined') return; // Ignore blank
+        const auth_type = c.auth.type.toLowerCase();
+        if (!smtp_client.auth_capabilities.includes(auth_type)) {
+            throw new Error(`Auth type "${auth_type}" not supported by server (supports: ${smtp_client.auth_capabilities.join(',')})`);
+        }
+        switch (auth_type) {
+            case 'plain':
+                if (!c.auth.user || !c.auth.pass) {
+                    throw new Error("Must include auth.user and auth.pass for PLAIN auth.");
+                }
+                logger.logdebug(`[smtp_client] uuid=${smtp_client.uuid} authenticating as "${c.auth.user}"`);
+                smtp_client.send_command('AUTH', `PLAIN ${utils.base64(`${c.auth.user}\0${c.auth.user}\0${c.auth.pass}`)}`);
+                break;
+            case 'cram-md5':
+                throw new Error("Not implemented");
+            default:
+                throw new Error(`Unknown AUTH type: ${auth_type}`);
+        }
+    });
 
-        smtp_client.on('auth', () => {
-            // if authentication has been handled by plugin(s)
-            if (smtp_client.authenticating) return;
+    smtp_client.on('auth', () => {
+        // if authentication has been handled by plugin(s)
+        if (smtp_client.authenticating) return;
 
-            if (smtp_client.is_dead_sender(plugin, connection)) return;
+        if (smtp_client.is_dead_sender(plugin, connection)) return;
 
-            smtp_client.authenticated = true;
-            smtp_client.send_command('MAIL', `FROM:${connection.transaction.mail_from.format(!smtp_client.smtp_utf8)}`);
-        });
+        smtp_client.authenticated = true;
+        smtp_client.send_command('MAIL', `FROM:${connection.transaction.mail_from.format(!smtp_client.smtp_utf8)}`);
+    });
 
-        // these errors only get thrown when the connection is still active
-        smtp_client.on('error', (msg) => {
-            connection.logwarn(plugin, msg);
-            smtp_client.call_next();
-        });
+    // these errors only get thrown when the connection is still active
+    smtp_client.on('error', (msg) => {
+        connection.logwarn(plugin, msg);
+        smtp_client.call_next();
+    });
 
-        // these are the errors thrown when the connection is dead
-        smtp_client.on('connection-error', (error) => {
-            // error contains e.g. "Error: connect ECONNREFUSE"
-            logger.logerror(`backend failure: ${smtp_client.host}:${smtp_client.port} - ${error}`);
-            const host_pool = connection.server.notes.host_pool;
-            // only exists for if forwarding_host_pool is set in the config
-            if (host_pool) {
-                host_pool.failed(smtp_client.host, smtp_client.port);
-            }
-            smtp_client.call_next();
-        });
+    // these are the errors thrown when the connection is dead
+    smtp_client.on('connection-error', (error) => {
+        // error contains e.g. "Error: connect ECONNREFUSE"
+        logger.logerror(`backend failure: ${smtp_client.host}:${smtp_client.port} - ${error}`);
+        const { host_pool } = connection.server.notes;
+        // only exists for if forwarding_host_pool is set in the config
+        if (host_pool) {
+            host_pool.failed(smtp_client.host, smtp_client.port);
+        }
+        smtp_client.call_next();
+    });
 
-        if (smtp_client.connected) {
-            if (smtp_client.xclient) {
-                smtp_client.send_command('XCLIENT', `ADDR=${connection.remote.ip}`);
-            }
-            else {
-                smtp_client.emit('helo');
-            }
+    if (smtp_client.connected) {
+        if (smtp_client.xclient) {
+            smtp_client.send_command('XCLIENT', `ADDR=${connection.remote.ip}`);
         }
+        else {
+            smtp_client.emit('helo');
+        }
+    }
 
-        callback(err, smtp_client);
-    });
+    callback(null, smtp_client);
 }
 
 function get_hostport (connection, server, cfg) {
@@ -539,15 +465,12 @@ function get_hostport (connection, server, cfg) {
         const host = server.notes.host_pool.get_host();
         if (host) return host; // { host: 1.2.3.4, port: 567 }
 
-        logger.logerror('[smtp_client_pool] no backend hosts in pool!');
+        logger.logerror('[smtp_client] no backend hosts in pool!');
         throw new Error("no backend hosts found in pool!");
     }
 
-    if (cfg.host && cfg.port) {
-        return { host: cfg.host, port: cfg.port };
-    }
+    if (cfg.host && cfg.port) return { host: cfg.host, port: cfg.port };
 
-    logger.logwarn("[smtp_client_pool] forwarding_host_pool or host and port " +
-            "were not found in config file");
+    logger.logwarn("[smtp_client] forwarding_host_pool or host and port were not found in config file");
     throw new Error("You must specify either forwarding_host_pool or host and port");
 }

package/tests/config/smtp_forward.ini

@@ -4,12 +4,6 @@ host=localhost
 ; port to connect to
 port=2555
 ;
-; timeout backend connection from pool
-;timeout=300
-;
-; max connections in pool
-;max_connections=1000
-;
 ; uncomment to enable TLS to the backend SMTP server
 enable_tls=true
 ;

package/tests/fixtures/line_socket.js

@@ -2,7 +2,7 @@
 
 const events   = require('events');
 const fixtures = require('haraka-test-fixtures');
-const stub     = fixtures.stub.stub;
+const { stub } = fixtures.stub;
 
 class Socket extends events.EventEmitter {
     constructor (port, host) {

package/tests/fixtures/util_hmailitem.js

@@ -1,10 +1,10 @@
 'use strict';
 
-const Address         = require('address-rfc2821').Address;
+const { Address }     = require('address-rfc2821');
 const fixtures        = require('haraka-test-fixtures');
 const stub_connection = fixtures.connection;
-// var transaction     = fixtures.transaction;  // not yet sufficient
-const transaction = require('../../transaction');
+// const transaction     = fixtures.transaction;  // not yet sufficient
+const transaction     = require('../../transaction');
 
 
 /**
@@ -91,8 +91,7 @@ exports.createHMailItem = (outbound_context, options, callback) => {
             callback('No hmail producted');
             return;
         }
-        for (let j=0; j<hmails.length; j++) {
-            const hmail = hmails[j];
+        for (const hmail of hmails) {
             hmail.hostlist = [ delivery_domain ];
             callback(null, hmail);
         }
@@ -153,8 +152,7 @@ function getNextEntryFromPlaybook (ofType, playbook) {
         return false;
     }
     if (playbook[0].from == ofType) {
-        const entry = playbook.shift();
-        return entry;
+        return playbook.shift();
     }
     return false;
 }

package/tests/fixtures/vm_harness.js

@@ -53,7 +53,7 @@ function make_test (module_path, test_path, additional_sandbox) {
 exports.add_tests = (module_path, tests_path, test_exports, add_to_sandbox) => {
     const additional_sandbox = add_to_sandbox || {};
     const tests = fs.readdirSync(tests_path).filter(dot_files);
-    for (let x = 0; x < tests.length; x++) {
-        test_exports[tests[x]] = make_test(module_path, tests_path + tests[x], additional_sandbox);
+    for (const test of tests) {
+        test_exports[test] = make_test(module_path, tests_path + test, additional_sandbox);
     }
 }

package/tests/host_pool.js

@@ -105,34 +105,33 @@ exports.HostPool = {
 
         let num_reqs = 0;
         const MockSocket = function MockSocket (pool) {
-            const self = this;
 
             // these are the methods called from probe_dead_host
 
             // setTimeout on the socket
-            self.pretendTimeout = () => {};
-            self.setTimeout = (ms, cb) => {
-                self.pretendTimeout = cb;
+            this.pretendTimeout = () => {};
+            this.setTimeout = (ms, cb) => {
+                this.pretendTimeout = cb;
             };
             // handle socket.on('error', ....
-            self.listeners = {};
-            self.on = (eventname, cb) => {
-                self.listeners[eventname] = cb;
+            this.listeners = {};
+            this.on = (eventname, cb) => {
+                this.listeners[eventname] = cb;
             };
-            self.emit = eventname => {
-                self.listeners[eventname]();
+            this.emit = eventname => {
+                this.listeners[eventname]();
             };
             // handle socket.connect(...
-            self.connected = () => {};
-            self.connect = (port, host, cb) => {
+            this.connected = () => {};
+            this.connect = (port, host, cb) => {
                 switch (++num_reqs) {
                     case 1:
                         // the first time through we pretend it timed out
-                        self.pretendTimeout();
+                        this.pretendTimeout();
                         break;
                     case 2:
                         // the second time through, pretend socket error
-                        self.emit('error');
+                        this.emit('error');
                         break;
                     case 3:
                         // the third time around, the socket connected
@@ -144,7 +143,7 @@ exports.HostPool = {
                         process.exit(1);
                 }
             };
-            self.destroy = () => {};
+            this.destroy = () => {};
 
         };
 

package/tests/installation/plugins/inherits.js

@@ -1,8 +1,7 @@
 "use strict";
 
 exports.register = function () {
-    const plugin = this;
-    plugin.inherits('base_plugin');
+    this.inherits('base_plugin');
 }
 
 exports.main_plugin_method = () => "main"

package/tests/logger.js

@@ -319,8 +319,8 @@ exports.add_log_methods = {
         this.logger.add_log_methods(testObj);
         const levels = ['DATA','PROTOCOL','DEBUG','INFO','NOTICE','WARN','ERROR','CRIT','ALERT','EMERG'];
         test.expect(levels.length);
-        for (let i=0; i<levels.length; i++) {
-            test.ok('function' === typeof(testObj[`log${levels[i].toLowerCase()}`]));
+        for (const level of levels) {
+            test.ok('function' === typeof(testObj[`log${level.toLowerCase()}`]));
         }
         test.done();
     },