laravel-echo-api-gateway 0.5.8 → 0.5.9

package/js-tests/Connector.test.ts

@@ -1,109 +1,344 @@
 import WS from "jest-websocket-mock";
 import { Connector } from "../js-src/Connector";
 import { Channel } from "../js-src/Channel";
-
-const mockedHost = 'ws://localhost:1234';
+import { flushPromises, identify, mockedHost, mockFetchResponse, restartServer } from "./helpers";
 
 describe('Connector', () => {
     let server: WS;
+    let connector: Connector;
 
     beforeEach(() => {
-        jest.useRealTimers();
-        server = new WS(mockedHost);
+        server = new WS(mockedHost, { jsonProtocol: true });
     });
 
     afterEach(() => {
-        server.close()
+        connector?.disconnect();
+        connector = undefined;
+        WS.clean();
+        jest.restoreAllMocks();
     });
 
     test('socket id is correctly set', async () => {
-        const connector = new Connector({
-            host: mockedHost,
-        })
-
-        await server.connected;
+        connector = new Connector({ host: mockedHost });
 
-        await expect(server).toReceiveMessage('{"event":"whoami"}');
-        server.send('{"event":"whoami","data":{"socket_id":"test-socket-id"}}')
+        await identify(server, 'test-socket-id');
 
-        expect(connector.socketId()).toBe('test-socket-id')
-    })
+        expect(connector.socketId()).toBe('test-socket-id');
+    });
 
     test('we reconnect to the server on error', async () => {
-        const connector = new Connector({
-            host: mockedHost,
-        })
+        connector = new Connector({ host: mockedHost, reconnectDelay: 10 });
 
-        await server.connected;
-        await expect(server).toReceiveMessage('{"event":"whoami"}');
-        server.send('{"event":"whoami","data":{"socket_id":"test-socket-id"}}')
+        await identify(server, 'test-socket-id');
 
-        server.close();
-        await server.closed;
-        server.server.stop(() => (server = new WS(mockedHost)));
+        server = await restartServer(server);
+        await identify(server, 'test-socket-id2');
 
-        await server.connected;
-        await expect(server).toReceiveMessage('{"event":"whoami"}');
-        server.send('{"event":"whoami","data":{"socket_id":"test-socket-id2"}}')
+        expect(connector.socketId()).toBe('test-socket-id2');
+    });
 
-        expect(connector.socketId()).toBe('test-socket-id2')
-    })
+    test('we only open one new connection per reconnect', async () => {
+        connector = new Connector({ host: mockedHost, reconnectDelay: 10 });
 
-    test('we can subscribe to a channel and listen to events', async () => {
-        const connector = new Connector({
-            host: mockedHost,
-        })
+        await identify(server, 'test-socket-id');
 
-        await server.connected;
+        server = await restartServer(server);
+        await identify(server, 'test-socket-id2');
+        await new Promise((resolve) => setTimeout(resolve, 50));
 
-        await expect(server).toReceiveMessage('{"event":"whoami"}');
-        server.send('{"event":"whoami","data":{"socket_id":"test-socket-id"}}')
+        expect(server.server.clients()).toHaveLength(1);
+    });
 
-        const channel = connector.channel('my-test-channel')
+    test('we keep retrying until the server is available, with a single connection', async () => {
+        WS.clean();
 
-        await expect(server).toReceiveMessage('{"event":"subscribe","data":{"channel":"my-test-channel"}}');
+        connector = new Connector({ host: mockedHost, reconnectDelay: 5, maxReconnectDelay: 20 });
+        await new Promise((resolve) => setTimeout(resolve, 60));
 
-        server.send('{"event":"subscription_succeeded","channel":"my-test-channel"}')
+        server = new WS(mockedHost, { jsonProtocol: true });
+        await identify(server, 'test-socket-id');
+        await new Promise((resolve) => setTimeout(resolve, 60));
 
-        expect(channel).toBeInstanceOf(Channel)
+        expect(connector.socketId()).toBe('test-socket-id');
+        expect(server.server.clients()).toHaveLength(1);
+    });
+
+    test('we can subscribe to a channel and listen to events', async () => {
+        connector = new Connector({ host: mockedHost });
+
+        await identify(server, 'test-socket-id');
+
+        const channel = connector.channel('my-test-channel');
+
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'my-test-channel' } });
+
+        expect(channel).toBeInstanceOf(Channel);
 
         const handler1 = jest.fn();
         const handler2 = jest.fn();
 
-        channel.on('my-test-event', handler1)
+        channel.listen('.my-test-event', handler1);
 
-        server.send('{"event":"my-test-event","channel":"my-test-channel","data":{}}')
+        server.send({ event: 'my-test-event', channel: 'my-test-channel', data: { id: 1 } });
 
-        expect(handler1).toBeCalled();
-        expect(handler2).not.toBeCalled();
-    })
+        expect(handler1).toHaveBeenCalledWith({ id: 1 });
+        expect(handler2).not.toHaveBeenCalled();
+    });
 
-    test('we can send a whisper event', async () => {
-        const connector = new Connector({
-            host: mockedHost,
-        })
+    test('channels subscribed before the connection is ready are subscribed once identified', async () => {
+        connector = new Connector({ host: mockedHost });
 
-        await server.connected;
+        connector.channel('early-channel');
 
-        await expect(server).toReceiveMessage('{"event":"whoami"}');
-        server.send('{"event":"whoami","data":{"socket_id":"test-socket-id"}}')
+        await identify(server, 'test-socket-id');
 
-        const channel = connector.channel('my-test-channel')
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'early-channel' } });
+    });
+
+    test('every listener of the same event is called', async () => {
+        connector = new Connector({ host: mockedHost });
+        await identify(server, 'test-socket-id');
+
+        const handler1 = jest.fn();
+        const handler2 = jest.fn();
+
+        connector.channel('my-test-channel').listen('.my-test-event', handler1);
+        connector.channel('my-test-channel').listen('.my-test-event', handler2);
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'my-test-channel' } });
 
-        await expect(server).toReceiveMessage('{"event":"subscribe","data":{"channel":"my-test-channel"}}');
+        server.send({ event: 'my-test-event', channel: 'my-test-channel', data: {} });
 
-        server.send('{"event":"subscription_succeeded","channel":"my-test-channel"}')
+        expect(handler1).toHaveBeenCalledTimes(1);
+        expect(handler2).toHaveBeenCalledTimes(1);
+    });
 
-        expect(channel).toBeInstanceOf(Channel)
+    test('stopListening with a callback only removes that callback', async () => {
+        connector = new Connector({ host: mockedHost });
+        await identify(server, 'test-socket-id');
 
         const handler1 = jest.fn();
         const handler2 = jest.fn();
 
-        channel.on('client-whisper', handler1)
+        const channel = connector.channel('my-test-channel')
+            .listen('.my-test-event', handler1)
+            .listen('.my-test-event', handler2);
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'my-test-channel' } });
+
+        channel.stopListening('.my-test-event', handler1);
+        server.send({ event: 'my-test-event', channel: 'my-test-channel', data: {} });
+
+        expect(handler1).not.toHaveBeenCalled();
+        expect(handler2).toHaveBeenCalledTimes(1);
+    });
+
+    test('stopListening without a callback removes every listener of the event', async () => {
+        connector = new Connector({ host: mockedHost });
+        await identify(server, 'test-socket-id');
+
+        const handler = jest.fn();
 
-        server.send('{"event":"client-whisper","data":"whisper","channel":"my-test-channel","data":{}}')
+        const channel = connector.channel('my-test-channel').listen('.my-test-event', handler);
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'my-test-channel' } });
 
-        expect(handler1).toBeCalled();
-        expect(handler2).not.toBeCalled();
-    })
+        channel.stopListening('.my-test-event');
+        server.send({ event: 'my-test-event', channel: 'my-test-channel', data: {} });
+
+        expect(handler).not.toHaveBeenCalled();
+    });
+
+    test('channels joined after connecting are resubscribed after a reconnect', async () => {
+        connector = new Connector({ host: mockedHost, reconnectDelay: 10 });
+        await identify(server, 'test-socket-id');
+
+        const handler = jest.fn();
+        connector.channel('late-channel').listen('.my-test-event', handler);
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'late-channel' } });
+
+        server = await restartServer(server);
+        await identify(server, 'test-socket-id2');
+
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'late-channel' } });
+
+        server.send({ event: 'my-test-event', channel: 'late-channel', data: {} });
+        expect(handler).toHaveBeenCalledTimes(1);
+    });
+
+    test('channels that were left are not resubscribed after a reconnect', async () => {
+        connector = new Connector({ host: mockedHost, reconnectDelay: 10 });
+        connector.channel('left-channel');
+        connector.channel('kept-channel');
+
+        await identify(server, 'test-socket-id');
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'left-channel' } });
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'kept-channel' } });
+
+        connector.leave('left-channel');
+        await expect(server).toReceiveMessage({ event: 'unsubscribe', data: { channel: 'left-channel' } });
+
+        server = await restartServer(server);
+        await identify(server, 'test-socket-id2');
+
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'kept-channel' } });
+        await flushPromises();
+        expect(server.messages).not.toContainEqual({ event: 'subscribe', data: { channel: 'left-channel' } });
+    });
+
+    test('pings are not duplicated after reconnecting', async () => {
+        connector = new Connector({ host: mockedHost, reconnectDelay: 10, pingInterval: 40 });
+        await identify(server, 'test-socket-id');
+
+        server = await restartServer(server);
+        await identify(server, 'test-socket-id2');
+
+        await new Promise((resolve) => setTimeout(resolve, 210));
+
+        const pings = server.messages.filter((message: any) => message.event === 'ping');
+        expect(pings.length).toBeGreaterThanOrEqual(3);
+        expect(pings.length).toBeLessThanOrEqual(6);
+    });
+
+    test('subscribed callbacks run when the server confirms the subscription', async () => {
+        connector = new Connector({ host: mockedHost });
+        await identify(server, 'test-socket-id');
+
+        const subscribed = jest.fn();
+        connector.channel('my-test-channel').subscribed(subscribed);
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'my-test-channel' } });
+
+        server.send({ event: 'subscription_succeeded', channel: 'my-test-channel', data: [] });
+
+        expect(subscribed).toHaveBeenCalledTimes(1);
+    });
+
+    test('we can send a whisper event and listen for whispers', async () => {
+        connector = new Connector({ host: mockedHost });
+        mockFetchResponse({ auth: 'signature' });
+        await identify(server, 'test-socket-id');
+
+        const channel = connector.privateChannel('my-test-channel');
+        await expect(server).toReceiveMessage({
+            event: 'subscribe',
+            data: { channel: 'private-my-test-channel', auth: 'signature' },
+        });
+
+        const handler = jest.fn();
+        channel.listenForWhisper('typing', handler);
+        channel.whisper('typing', { name: 'Ana' });
+
+        await expect(server).toReceiveMessage({
+            event: 'client-typing',
+            channel: 'private-my-test-channel',
+            data: { name: 'Ana' },
+        });
+
+        server.send({ event: 'client-typing', channel: 'private-my-test-channel', data: { name: 'Luis' } });
+        expect(handler).toHaveBeenCalledWith({ name: 'Luis' });
+    });
+
+    describe('private channel authorization', () => {
+        test('posts to the auth endpoint with the configured headers', async () => {
+            const fetchMock = mockFetchResponse({ auth: 'signature' });
+
+            connector = new Connector({
+                host: mockedHost,
+                authEndpoint: 'https://app.test/broadcasting/auth',
+                bearerToken: 'secret-token',
+                auth: { headers: { 'X-Tenant': 'tenant-1' } },
+            });
+            connector.privateChannel('orders');
+
+            await identify(server, 'test-socket-id');
+
+            await expect(server).toReceiveMessage({
+                event: 'subscribe',
+                data: { channel: 'private-orders', auth: 'signature' },
+            });
+            expect(fetchMock).toHaveBeenCalledWith('https://app.test/broadcasting/auth', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    'Authorization': 'Bearer secret-token',
+                    'X-Tenant': 'tenant-1',
+                },
+                body: JSON.stringify({ socket_id: 'test-socket-id', channel_name: 'private-orders' }),
+            });
+        });
+
+        test('uses channelAuthorization endpoint and headers when given', async () => {
+            const fetchMock = mockFetchResponse({ auth: 'signature' });
+
+            connector = new Connector({
+                host: mockedHost,
+                channelAuthorization: {
+                    endpoint: 'https://api.test/broadcasting/auth',
+                    headers: { 'X-Api-Key': 'key' },
+                },
+            });
+            connector.privateChannel('orders');
+
+            await identify(server, 'test-socket-id');
+            await expect(server).toReceiveMessage({
+                event: 'subscribe',
+                data: { channel: 'private-orders', auth: 'signature' },
+            });
+
+            expect(fetchMock).toHaveBeenCalledWith('https://api.test/broadcasting/auth', expect.objectContaining({
+                headers: expect.objectContaining({ 'X-Api-Key': 'key' }),
+            }));
+        });
+
+        test('uses channelAuthorization.customHandler when given', async () => {
+            const fetchMock = mockFetchResponse({ auth: 'from-fetch' });
+            const customHandler = jest.fn((params, callback) => callback(null, { auth: 'from-handler' }));
+
+            connector = new Connector({ host: mockedHost, channelAuthorization: { customHandler } });
+            connector.privateChannel('orders');
+
+            await identify(server, 'test-socket-id');
+            await expect(server).toReceiveMessage({
+                event: 'subscribe',
+                data: { channel: 'private-orders', auth: 'from-handler' },
+            });
+
+            expect(customHandler).toHaveBeenCalledWith(
+                { socketId: 'test-socket-id', channelName: 'private-orders' },
+                expect.any(Function),
+            );
+            expect(fetchMock).not.toHaveBeenCalled();
+        });
+
+        test('reports a failed authorization to the channel error callbacks', async () => {
+            mockFetchResponse({ message: 'Forbidden' }, false, 403);
+
+            connector = new Connector({ host: mockedHost });
+            const onError = jest.fn();
+            connector.privateChannel('orders').error(onError);
+
+            await identify(server, 'test-socket-id');
+            await flushPromises();
+            await flushPromises();
+
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ type: 'AuthError', status: 403 }));
+            expect(server.messages).not.toContainEqual(expect.objectContaining({ event: 'subscribe' }));
+        });
+
+        test('reports a rejected subscription to the channel error callbacks', async () => {
+            mockFetchResponse({ auth: 'bad-signature' });
+
+            connector = new Connector({ host: mockedHost });
+            const onError = jest.fn();
+            connector.privateChannel('orders').error(onError);
+
+            await identify(server, 'test-socket-id');
+            await expect(server).toReceiveMessage({
+                event: 'subscribe',
+                data: { channel: 'private-orders', auth: 'bad-signature' },
+            });
+
+            server.send({ event: 'error', channel: 'private-orders', data: { message: 'Invalid auth signature' } });
+
+            expect(onError).toHaveBeenCalledWith({ message: 'Invalid auth signature' });
+        });
+    });
 });

package/js-tests/EchoCompatibility.test.ts

@@ -0,0 +1,96 @@
+import WS from "jest-websocket-mock";
+import EchoV2 from "laravel-echo";
+import { Connector, broadcaster } from "../js-src/Connector";
+import { identify, mockedHost, mockFetchResponse } from "./helpers";
+
+// laravel-echo v1, installed under an alias. Its CommonJS build exports the class itself.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const echoV1Module = require("laravel-echo-v1");
+const EchoV1 = echoV1Module.default ?? echoV1Module;
+
+const echoVersions: Array<[string, any]> = [
+    ['laravel-echo v1', EchoV1],
+    ['laravel-echo v2', EchoV2],
+];
+
+describe.each(echoVersions)('%s', (_version, Echo) => {
+    let server: WS;
+    let echo: any;
+
+    beforeEach(() => {
+        server = new WS(mockedHost, { jsonProtocol: true });
+    });
+
+    afterEach(() => {
+        echo?.disconnect();
+        echo = undefined;
+        WS.clean();
+    });
+
+    test.each([
+        ['Connector class', Connector],
+        ['broadcaster export', broadcaster],
+    ])('accepts the %s as broadcaster', async (_label, broadcasterOption) => {
+        echo = new Echo({ broadcaster: broadcasterOption, host: mockedHost });
+
+        await identify(server, 'socket-1');
+
+        expect(echo.connector).toBeInstanceOf(Connector);
+        expect(echo.socketId()).toBe('socket-1');
+    });
+
+    test('authorizes a private channel and delivers namespaced events', async () => {
+        const fetchMock = mockFetchResponse({ auth: 'signature' });
+
+        echo = new Echo({
+            broadcaster: Connector,
+            host: mockedHost,
+            authEndpoint: 'https://app.test/broadcasting/auth',
+            bearerToken: 'secret-token',
+        });
+
+        const handler = jest.fn();
+        echo.private('orders').listen('OrderCreated', handler);
+
+        await identify(server, 'socket-1');
+
+        await expect(server).toReceiveMessage({
+            event: 'subscribe',
+            data: { channel: 'private-orders', auth: 'signature' },
+        });
+
+        expect(fetchMock).toHaveBeenCalledWith('https://app.test/broadcasting/auth', expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({ Authorization: 'Bearer secret-token' }),
+            body: JSON.stringify({ socket_id: 'socket-1', channel_name: 'private-orders' }),
+        }));
+
+        server.send({ event: 'App\\Events\\OrderCreated', channel: 'private-orders', data: { id: 1 } });
+
+        expect(handler).toHaveBeenCalledWith({ id: 1 });
+    });
+
+    test('leaving a channel unsubscribes from it', async () => {
+        echo = new Echo({ broadcaster: Connector, host: mockedHost });
+
+        echo.channel('news');
+        await identify(server, 'socket-1');
+        await expect(server).toReceiveMessage({ event: 'subscribe', data: { channel: 'news' } });
+
+        echo.leave('news');
+
+        await expect(server).toReceiveMessage({ event: 'unsubscribe', data: { channel: 'news' } });
+    });
+});
+
+describe('Connector', () => {
+    afterEach(() => WS.clean());
+
+    test('does not open a connection when constructed without options', () => {
+        // laravel-echo v2 probes custom broadcasters by calling `new broadcaster()` without arguments.
+        const server = new WS(mockedHost, { jsonProtocol: true });
+
+        expect(() => new Connector()).not.toThrow();
+        expect(server.server.clients()).toHaveLength(0);
+    });
+});

package/js-tests/helpers.ts

@@ -0,0 +1,37 @@
+import WS from "jest-websocket-mock";
+
+export const mockedHost = 'ws://localhost:1234';
+
+/**
+ * Wait for the client to connect and ask for its socket id, then answer with the given id.
+ */
+export async function identify(server: WS, socketId: string): Promise<void> {
+    await server.connected;
+    await expect(server).toReceiveMessage({ event: 'whoami' });
+    server.send({ event: 'whoami', data: { socket_id: socketId } });
+}
+
+/**
+ * Close the current mock server and start a fresh one on the same host, simulating a dropped connection.
+ */
+export async function restartServer(server: WS): Promise<WS> {
+    server.close();
+    await server.closed;
+    WS.clean();
+
+    return new WS(mockedHost, { jsonProtocol: true });
+}
+
+export function mockFetchResponse(body: object, ok = true, status = 200): jest.Mock {
+    const fetchMock = jest.fn().mockResolvedValue({
+        ok,
+        status,
+        json: () => Promise.resolve(body),
+    });
+
+    (globalThis as any).fetch = fetchMock;
+
+    return fetchMock;
+}
+
+export const flushPromises = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "laravel-echo-api-gateway",
-    "version": "0.5.8",
+    "version": "0.5.9",
     "description": "Use Laravel Echo with API Gateway Websockets",
     "keywords": [
         "laravel",
@@ -21,46 +21,39 @@
     "license": "MIT",
     "main": "dist/laravel-echo-api-gateway.common.js",
     "module": "dist/laravel-echo-api-gateway.js",
-    "types": "dist/laravel-echo-api-gateway.d.ts",
+    "types": "dist/Connector.d.ts",
     "scripts": {
         "build": "npm run compile && npm run declarations",
         "compile": "./node_modules/.bin/rollup -c",
         "declarations": "./node_modules/.bin/tsc --emitDeclarationOnly",
         "lint": "eslint --ext .js,.ts ./js-src ./js-tests",
-        "prepublish": "npm run build",
         "release": "npm run test && standard-version && git push --follow-tags && npm publish",
-        "test": "jest"
+        "test": "jest",
+        "prepare": "npm run build"
     },
     "devDependencies": {
-        "@babel/plugin-proposal-decorators": "^7.8.3",
-        "@babel/plugin-proposal-export-namespace-from": "^7.8.3",
-        "@babel/plugin-proposal-function-sent": "^7.8.3",
-        "@babel/plugin-proposal-numeric-separator": "^7.8.3",
-        "@babel/plugin-proposal-throw-expressions": "^7.8.3",
-        "@babel/plugin-transform-object-assign": "^7.8.3",
-        "@babel/preset-env": "^7.9.6",
-        "@rollup/plugin-babel": "^5.0.0",
-        "@types/babel__traverse": "^7.20.6",
-        "@types/jest": "^24.0.18",
-        "@types/node": "^12.7.5",
-        "@typescript-eslint/eslint-plugin": "^3.7.0",
-        "@typescript-eslint/parser": "^3.7.0",
+        "@rollup/plugin-typescript": "^12.3.0",
+        "@types/jest": "^29.5.14",
+        "@types/node": "^20.19.43",
+        "@typescript-eslint/eslint-plugin": "^5.62.0",
+        "@typescript-eslint/parser": "^5.62.0",
         "eslint": "^7.5.0",
-        "jest": "^24.9.0",
-        "jest-websocket-mock": "^2.2.0",
-        "laravel-echo": "1.10.0",
-        "mock-socket": "^9.0.3",
-        "rollup": "^2.10.2",
-        "rollup-plugin-commonjs": "^10.1.0",
-        "rollup-plugin-json": "^4.0.0",
-        "rollup-plugin-node-resolve": "^5.2.0",
-        "rollup-plugin-typescript2": "^0.27.1",
+        "jest": "^29.7.0",
+        "jest-environment-jsdom": "^29.7.0",
+        "jest-websocket-mock": "^2.5.0",
+        "laravel-echo": "^2.5.0",
+        "laravel-echo-v1": "npm:laravel-echo@^1.10.0",
+        "mock-socket": "^9.3.1",
+        "rollup": "^4.64.0",
         "standard-version": "^8.0.1",
-        "ts-jest": "^24.1.0",
-        "tslib": "^1.10.0",
-        "typescript": "^5.7.2"
+        "ts-jest": "^29.4.14",
+        "tslib": "^2.8.1",
+        "typescript": "^5.9.3"
     },
     "engines": {
-        "node": ">=10"
+        "node": ">=18"
+    },
+    "peerDependencies": {
+        "laravel-echo": "^1.10.0 || ^2.0.0"
     }
 }

package/phpstan.neon.dist

@@ -1,21 +1,12 @@
 includes:
-    - ./vendor/nunomaduro/larastan/extension.neon
+    - ./vendor/larastan/larastan/extension.neon
 
 parameters:
 
-    phpVersion: 80399
-
     paths:
         - src
-        - tests
 
-    level: max
+    level: 6
 
     ignoreErrors:
-        - '#^Cannot call method debug\(\) on Illuminate\\Log\\LogManager\|null.$#'
-        - '#^Call to an undefined method Mockery\\ExpectationInterface\|Mockery\\HigherOrderMessage::withArgs\(\).$#'
-    #
-    #    excludePaths:
-    #        - ./*/*/FileToBeExcluded.php
-
-    checkMissingIterableValueType: false
+        - identifier: missingType.iterableValue

package/phpunit.xml

@@ -9,9 +9,9 @@
             <directory suffix="Test.php">./tests</directory>
         </testsuite>
     </testsuites>
-    <coverage processUncoveredFiles="true">
+    <source>
         <include>
             <directory suffix=".php">./src</directory>
         </include>
-    </coverage>
+    </source>
 </phpunit>