test: replace custom assert helper with direct imports

Author: theorderingmachine

AGENTS.md

@@ -171,7 +171,7 @@ test/types/         # tsd type tests
 ### Test Conventions
 
 - **Test files** use `*.spec.ts` suffix
-- **Assertions** use the local `test/unit/helpers/assert.ts` compatibility helper backed by Node.js `assert` and Sinon assertions
+- **Assertions** in tests use direct `node:assert/strict` and `sinon.assert` imports
 - **Mocking** uses sinon (`stub`, `spy`, `fake`) and proxyquire for module-level dependency replacement
 - **Test config** lives in `package.json` scripts plus direct `node:test` imports in the spec files
 - **Where to put new tests:** Mirror the source structure. For `src/Foo.ts`, add `test/unit/Foo.spec.ts`. For `src/receivers/Bar.ts`, add `test/unit/receivers/Bar.spec.ts`.

test/unit/App/basic.spec.ts

@@ -1,5 +1,5 @@
 import { LogLevel } from '@slack/logger';
-import { assert } from '../helpers/assert';
+import assert from 'node:assert/strict';
 import sinon from 'sinon';
 import { ErrorCode } from '../../../src/errors';
 import SocketModeReceiver from '../../../src/receivers/SocketModeReceiver';
@@ -35,13 +35,17 @@ describe('App basic features', () => {
         const MockApp = importApp(overrides);
         const app = new MockApp({ token: '', signingSecret: '', port: 9999 });
         // biome-ignore lint/complexity/useLiteralKeys: reaching into private fields
-        assert.propertyVal(app['receiver'], 'port', 9999);
+                assert.ok(app['receiver'] && typeof app['receiver'] === 'object');
+        assert.ok('port' in app['receiver']);
+        assert.deepStrictEqual((app['receiver'] as unknown as Record<PropertyKey, unknown>)['port'], 9999);
       });
       it('should accept a port value under installerOptions', async () => {
         const MockApp = importApp(overrides);
         const app = new MockApp({ token: '', signingSecret: '', port: 7777, installerOptions: { port: 9999 } });
         // biome-ignore lint/complexity/useLiteralKeys: reaching into private fields
-        assert.propertyVal(app['receiver'], 'port', 9999);
+                assert.ok(app['receiver'] && typeof app['receiver'] === 'object');
+        assert.ok('port' in app['receiver']);
+        assert.deepStrictEqual((app['receiver'] as unknown as Record<PropertyKey, unknown>)['port'], 9999);
       });
     });
 
@@ -66,7 +70,9 @@ describe('App basic features', () => {
           installationStore,
         });
         // biome-ignore lint/complexity/useLiteralKeys: reaching into private fields
-        assert.propertyVal(app['receiver'], 'httpServerPort', 9999);
+                assert.ok(app['receiver'] && typeof app['receiver'] === 'object');
+        assert.ok('httpServerPort' in app['receiver']);
+        assert.deepStrictEqual((app['receiver'] as unknown as Record<PropertyKey, unknown>)['httpServerPort'], 9999);
       });
       it('should accept a port value under installerOptions', async () => {
         const MockApp = importApp(overrides);
@@ -83,7 +89,9 @@ describe('App basic features', () => {
           installationStore,
         });
         // biome-ignore lint/complexity/useLiteralKeys: reaching into private fields
-        assert.propertyVal(app['receiver'], 'httpServerPort', 9999);
+                assert.ok(app['receiver'] && typeof app['receiver'] === 'object');
+        assert.ok('httpServerPort' in app['receiver']);
+        assert.deepStrictEqual((app['receiver'] as unknown as Record<PropertyKey, unknown>)['httpServerPort'], 9999);
       });
     });
 
@@ -94,12 +102,12 @@ describe('App basic features', () => {
         const MockApp = importApp(overrides);
         const app = new MockApp({ token: '', signingSecret: '' });
         // TODO: verify that the fake bot ID and fake bot user ID are retrieved
-        assert.instanceOf(app, MockApp);
+        assert.ok(app instanceof MockApp);
       });
       it('should pass the given token to app.client', async () => {
         const MockApp = importApp(overrides);
         const app = new MockApp({ token: 'xoxb-foo-bar', signingSecret: '' });
-        assert.isDefined(app.client);
+        assert.notStrictEqual(app.client, undefined);
         assert.equal(app.client.token, 'xoxb-foo-bar');
       });
     });
@@ -115,7 +123,9 @@ describe('App basic features', () => {
         new MockApp({ signingSecret: '' });
         assert.fail();
       } catch (error) {
-        assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                assert.ok(error && typeof error === 'object');
+        assert.ok('code' in error);
+        assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
       }
     });
     it('should fail when both a token and authorize callback are specified', async () => {
@@ -125,7 +135,9 @@ describe('App basic features', () => {
         new MockApp({ token: '', authorize: authorizeCallback, signingSecret: '' });
         assert.fail();
       } catch (error) {
-        assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                assert.ok(error && typeof error === 'object');
+        assert.ok('code' in error);
+        assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
         assert(authorizeCallback.notCalled);
       }
     });
@@ -136,7 +148,9 @@ describe('App basic features', () => {
         new MockApp({ token: '', clientId: '', clientSecret: '', stateSecret: '', signingSecret: '' });
         assert.fail();
       } catch (error) {
-        assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                assert.ok(error && typeof error === 'object');
+        assert.ok('code' in error);
+        assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
         assert(authorizeCallback.notCalled);
       }
     });
@@ -153,7 +167,9 @@ describe('App basic features', () => {
         });
         assert.fail();
       } catch (error) {
-        assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                assert.ok(error && typeof error === 'object');
+        assert.ok('code' in error);
+        assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
         assert(authorizeCallback.notCalled);
       }
     });
@@ -172,7 +188,9 @@ describe('App basic features', () => {
         new MockApp({ authorize: noop });
         assert.fail();
       } catch (error) {
-        assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                assert.ok(error && typeof error === 'object');
+        assert.ok('code' in error);
+        assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
       }
     });
     it('should fail when both socketMode and a custom receiver are specified', async () => {
@@ -182,7 +200,9 @@ describe('App basic features', () => {
         new MockApp({ token: '', signingSecret: '', socketMode: true, receiver: fakeReceiver });
         assert.fail();
       } catch (error) {
-        assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                assert.ok(error && typeof error === 'object');
+        assert.ok('code' in error);
+        assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
       }
     });
     it('should succeed when both socketMode and SocketModeReceiver are specified', async () => {
@@ -221,7 +241,7 @@ describe('App basic features', () => {
         const dummyConvoStore = createFakeConversationStore();
         const MockApp = importApp(overrides);
         const app = new MockApp({ convoStore: dummyConvoStore, authorize: noop, signingSecret: '' });
-        assert.instanceOf(app, MockApp);
+        assert.ok(app instanceof MockApp);
         assert(fakeConversationContext.firstCall.calledWith(dummyConvoStore));
       });
     });
@@ -232,7 +252,9 @@ describe('App basic features', () => {
           new MockApp({ token: '', signingSecret: '', redirectUri: 'http://example.com/redirect' }); // eslint-disable-line no-new
           assert.fail();
         } catch (error) {
-          assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                    assert.ok(error && typeof error === 'object');
+          assert.ok('code' in error);
+          assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
         }
       });
       it('should fail when missing installerOptions.redirectUriPath', async () => {
@@ -246,7 +268,9 @@ describe('App basic features', () => {
           });
           assert.fail();
         } catch (error) {
-          assert.propertyVal(error, 'code', ErrorCode.AppInitializationError);
+                    assert.ok(error && typeof error === 'object');
+          assert.ok('code' in error);
+          assert.deepStrictEqual((error as unknown as Record<PropertyKey, unknown>)['code'], ErrorCode.AppInitializationError);
         }
       });
     });
@@ -307,23 +331,23 @@ describe('App basic features', () => {
           signingSecret: 'invalid-one',
           deferInitialization: true,
         });
-        assert.instanceOf(app, MockApp);
+        assert.ok(app instanceof MockApp);
         try {
           await app.start();
           assert.fail('The start() method should fail before init() call');
         } catch (err) {
-          assert.propertyVal(
-            err,
-            'message',
-            'This App instance is not yet initialized. Call `await App#init()` before starting the app.',
-          );
+                    assert.ok(err && typeof err === 'object');
+          assert.ok('message' in err);
+          assert.deepStrictEqual((err as unknown as Record<PropertyKey, unknown>)['message'], 'This App instance is not yet initialized. Call `await App#init()` before starting the app.');
         }
         try {
           await app.init();
           assert.fail('The init() method should fail here');
         } catch (err) {
           console.log(err);
-          assert.propertyVal(err, 'message', exception);
+                    assert.ok(err && typeof err === 'object');
+          assert.ok('message' in err);
+          assert.deepStrictEqual((err as unknown as Record<PropertyKey, unknown>)['message'], exception);
         }
       });
     });
@@ -337,8 +361,12 @@ describe('App basic features', () => {
         const fakeLogger = createFakeLogger();
         const MockApp = importApp(overrides);
         const app = new MockApp({ logger: fakeLogger, token: '', appToken: fakeAppToken, developerMode: true });
-        assert.propertyVal(app, 'logLevel', LogLevel.DEBUG);
-        assert.propertyVal(app, 'socketMode', true);
+                assert.ok(app && typeof app === 'object');
+        assert.ok('logLevel' in app);
+        assert.deepStrictEqual((app as unknown as Record<PropertyKey, unknown>)['logLevel'], LogLevel.DEBUG);
+                assert.ok(app && typeof app === 'object');
+        assert.ok('socketMode' in app);
+        assert.deepStrictEqual((app as unknown as Record<PropertyKey, unknown>)['socketMode'], true);
       });
     });
 

test/unit/App/middlewares/arguments.spec.ts

@@ -1,5 +1,5 @@
 import type { WebClient } from '@slack/web-api';
-import { assert } from '../../helpers/assert';
+import assert from 'node:assert/strict';
 import sinon, { type SinonSpy } from 'sinon';
 import { LogLevel } from '../../../../src/App';
 import type { SayStreamFn } from '../../../../src/context/create-say-stream';
@@ -429,7 +429,7 @@ describe('App middleware and listener arguments', () => {
 
       sinon.assert.calledThrice(fakeAck);
 
-      assert.isUndefined(app.client.token);
+      assert.strictEqual(app.client.token, undefined);
       assert.equal(clients[0].token, 'xoxb-123');
       assert.equal(clients[1].token, 'xoxp-456');
       assert.equal(clients[2].token, 'xoxb-123');
@@ -546,8 +546,12 @@ describe('App middleware and listener arguments', () => {
         // Assert that each call to fakePostMessage had the right arguments
         for (const call of fakePostMessage.getCalls()) {
           const firstArg = call.args[0];
-          assert.propertyVal(firstArg, 'text', dummyMessage);
-          assert.propertyVal(firstArg, 'channel', dummyChannelId);
+                    assert.ok(firstArg && typeof firstArg === 'object');
+          assert.ok('text' in firstArg);
+          assert.deepStrictEqual((firstArg as unknown as Record<PropertyKey, unknown>)['text'], dummyMessage);
+                    assert.ok(firstArg && typeof firstArg === 'object');
+          assert.ok('channel' in firstArg);
+          assert.deepStrictEqual((firstArg as unknown as Record<PropertyKey, unknown>)['channel'], dummyChannelId);
         }
         sinon.assert.notCalled(fakeErrorHandler);
       });
@@ -573,8 +577,12 @@ describe('App middleware and listener arguments', () => {
         // Assert that each call to fakePostMessage had the right arguments
         for (const call of fakePostMessage.getCalls()) {
           const firstArg = call.args[0];
-          assert.propertyVal(firstArg, 'channel', dummyChannelId);
-          assert.propertyVal(firstArg, 'text', dummyMessage.text);
+                    assert.ok(firstArg && typeof firstArg === 'object');
+          assert.ok('channel' in firstArg);
+          assert.deepStrictEqual((firstArg as unknown as Record<PropertyKey, unknown>)['channel'], dummyChannelId);
+                    assert.ok(firstArg && typeof firstArg === 'object');
+          assert.ok('text' in firstArg);
+          assert.deepStrictEqual((firstArg as unknown as Record<PropertyKey, unknown>)['text'], dummyMessage.text);
         }
         sinon.assert.notCalled(fakeErrorHandler);
       });
@@ -635,7 +643,7 @@ describe('App middleware and listener arguments', () => {
 
         const app = new MockApp({ receiver: fakeReceiver, authorize: sinon.fake.resolves(dummyAuthorizationResult) });
         app.use(async (args) => {
-          assert.notProperty(args, 'say');
+          assert.ok(!('say' in args));
           // If the above assertion fails, then it would throw an AssertionError and the following line will not be
           // called
           assertionAggregator();
@@ -679,7 +687,7 @@ describe('App middleware and listener arguments', () => {
       app.use(async (args) => {
         // biome-ignore lint/suspicious/noExplicitAny: test utility
         const sayStream = (args as any).sayStream as SayStreamFn;
-        assert.isFunction(sayStream);
+        assert.strictEqual(typeof sayStream, 'function');
         assertionAggregator();
       });
       app.error(fakeErrorHandler);
@@ -743,7 +751,7 @@ describe('App middleware and listener arguments', () => {
       const assertionAggregator = sinon.fake();
       const app = new MockApp({ receiver: fakeReceiver, authorize: sinon.fake.resolves(dummyAuthorizationResult) });
       app.use(async (args) => {
-        assert.notProperty(args, 'sayStream');
+        assert.ok(!('sayStream' in args));
         assertionAggregator();
       });
 
@@ -773,7 +781,7 @@ describe('App middleware and listener arguments', () => {
       app.use(async (args) => {
         // biome-ignore lint/suspicious/noExplicitAny: test utility
         const setStatus = (args as any).setStatus as SetStatusFn;
-        assert.isFunction(setStatus);
+        assert.strictEqual(typeof setStatus, 'function');
         assertionAggregator();
       });
       app.error(fakeErrorHandler);
@@ -802,7 +810,7 @@ describe('App middleware and listener arguments', () => {
       const assertionAggregator = sinon.fake();
       const app = new MockApp({ receiver: fakeReceiver, authorize: sinon.fake.resolves(dummyAuthorizationResult) });
       app.use(async (args) => {
-        assert.notProperty(args, 'setStatus');
+        assert.ok(!('setStatus' in args));
         assertionAggregator();
       });
 
@@ -959,7 +967,7 @@ describe('App middleware and listener arguments', () => {
         ack: fakeAck,
       });
 
-      assert.isTrue(called);
+      assert.strictEqual(called, true);
       sinon.assert.calledOnce(fakeAck);
     });