chore: Improve test coverage for realtime_client

Author: dshukertjr

packages/realtime_client/test/channel_test.dart

@@ -352,7 +352,7 @@ void main() {
           RealtimeChannel('topic', socket, params: RealtimeChannelConfig());
     });
 
-    test('description', () async {
+    test('presence callbacks work correctly', () async {
       bool syncCalled = false, joinCalled = false, leaveCalled = false;
       channel.onPresenceSync((payload) {
         syncCalled = true;
@@ -386,4 +386,104 @@ void main() {
       expect(leaveCalled, isTrue);
     });
   });
+
+  group('postgres changes', () {
+    setUp(() {
+      socket = RealtimeClient('', timeout: const Duration(milliseconds: 1234));
+      channel =
+          RealtimeChannel('topic', socket, params: RealtimeChannelConfig());
+    });
+
+    test('onPostgresChanges registers postgres change listener', () {
+      var called = false;
+      PostgresChangePayload? receivedPayload;
+
+      channel.onPostgresChanges(
+        event: PostgresChangeEvent.insert,
+        schema: 'public',
+        table: 'users',
+        callback: (payload) {
+          called = true;
+          receivedPayload = payload;
+        },
+      );
+
+      // Simulate postgres change event
+      final payload = {
+        'schema': 'public',
+        'table': 'users',
+        'eventType': 'INSERT',
+        'new': {'id': 1, 'name': 'John'},
+        'old': {},
+        'commit_timestamp': '2023-01-01T00:00:00Z',
+        'errors': null,
+      };
+
+      channel.trigger('postgres_changes', {
+        'type': 'INSERT',
+        ...payload,
+      });
+
+      expect(called, isTrue);
+      expect(receivedPayload?.eventType, PostgresChangeEvent.insert);
+      expect(receivedPayload?.newRecord['name'], 'John');
+    });
+  });
+
+  group('broadcast', () {
+    setUp(() {
+      socket = RealtimeClient('', timeout: const Duration(milliseconds: 1234));
+      channel =
+          RealtimeChannel('topic', socket, params: RealtimeChannelConfig());
+    });
+
+    test('onBroadcast registers broadcast listener', () {
+      var called = false;
+      Map<String, dynamic>? receivedPayload;
+
+      channel.onBroadcast(
+        event: 'chat_message',
+        callback: (payload) {
+          called = true;
+          receivedPayload = payload;
+        },
+      );
+
+      // Simulate broadcast event
+      channel.trigger('broadcast', {
+        'event': 'chat_message',
+        'payload': {'text': 'Hello world'},
+      });
+
+      expect(called, isTrue);
+      expect(receivedPayload?['payload']['text'], 'Hello world');
+    });
+  });
+
+  group('helper methods', () {
+    setUp(() {
+      socket = RealtimeClient('', timeout: const Duration(milliseconds: 1234));
+      channel =
+          RealtimeChannel('topic', socket, params: RealtimeChannelConfig());
+    });
+
+    test('replyEventName generates correct event name', () {
+      expect(channel.replyEventName('ref123'), 'chan_reply_ref123');
+      expect(channel.replyEventName(null), '');
+    });
+
+    test('isMember checks topic membership correctly', () {
+      expect(channel.isMember('topic'), isTrue);
+      expect(channel.isMember('other:topic'), isFalse);
+      expect(channel.isMember('*'), isTrue);
+    });
+
+    test('state getters return correct values', () {
+      expect(channel.isClosed, isTrue);
+      expect(channel.isErrored, isFalse);
+      expect(channel.isJoined, isFalse);
+      expect(channel.isJoining, isFalse);
+      expect(channel.isLeaving, isFalse);
+    });
+  });
 }

packages/realtime_client/test/constants_test.dart

@@ -0,0 +1,112 @@
+import 'package:realtime_client/src/constants.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Constants', () {
+    test('has correct values', () {
+      expect(Constants.vsn, '1.0.0');
+      expect(Constants.defaultTimeout.inMilliseconds, 10000);
+      expect(Constants.defaultHeartbeatIntervalMs, 25000);
+      expect(Constants.wsCloseNormal, 1000);
+      expect(Constants.defaultHeaders, isA<Map<String, String>>());
+      expect(Constants.defaultHeaders.containsKey('X-Client-Info'), isTrue);
+    });
+  });
+
+  group('RealtimeConstants', () {
+    test('is type alias for Constants', () {
+      expect(RealtimeConstants.vsn, Constants.vsn);
+    });
+  });
+
+  group('SocketStates', () {
+    test('enum values exist', () {
+      expect(SocketStates.connecting, isNotNull);
+      expect(SocketStates.open, isNotNull);
+      expect(SocketStates.disconnecting, isNotNull);
+      expect(SocketStates.closed, isNotNull);
+      expect(SocketStates.disconnected, isNotNull);
+    });
+  });
+
+  group('ChannelStates', () {
+    test('enum values exist', () {
+      expect(ChannelStates.closed, isNotNull);
+      expect(ChannelStates.errored, isNotNull);
+      expect(ChannelStates.joined, isNotNull);
+      expect(ChannelStates.joining, isNotNull);
+      expect(ChannelStates.leaving, isNotNull);
+    });
+  });
+
+  group('ChannelEvents', () {
+    test('enum values exist', () {
+      expect(ChannelEvents.close, isNotNull);
+      expect(ChannelEvents.error, isNotNull);
+      expect(ChannelEvents.join, isNotNull);
+      expect(ChannelEvents.reply, isNotNull);
+      expect(ChannelEvents.leave, isNotNull);
+      expect(ChannelEvents.heartbeat, isNotNull);
+      expect(ChannelEvents.accessToken, isNotNull);
+      expect(ChannelEvents.broadcast, isNotNull);
+      expect(ChannelEvents.presence, isNotNull);
+      expect(ChannelEvents.postgresChanges, isNotNull);
+    });
+  });
+
+  group('ChannelEventsExtended', () {
+    test('fromType returns correct enum from name', () {
+      expect(ChannelEventsExtended.fromType('close'), ChannelEvents.close);
+      expect(ChannelEventsExtended.fromType('error'), ChannelEvents.error);
+      expect(ChannelEventsExtended.fromType('join'), ChannelEvents.join);
+    });
+
+    test('fromType returns correct enum from eventName', () {
+      expect(ChannelEventsExtended.fromType('phx_close'), ChannelEvents.close);
+      expect(ChannelEventsExtended.fromType('phx_error'), ChannelEvents.error);
+      expect(ChannelEventsExtended.fromType('access_token'),
+          ChannelEvents.accessToken);
+      expect(ChannelEventsExtended.fromType('postgres_changes'),
+          ChannelEvents.postgresChanges);
+      expect(
+          ChannelEventsExtended.fromType('broadcast'), ChannelEvents.broadcast);
+      expect(
+          ChannelEventsExtended.fromType('presence'), ChannelEvents.presence);
+    });
+
+    test('fromType throws for invalid type', () {
+      expect(
+          () => ChannelEventsExtended.fromType('invalid_type'),
+          throwsA(isA<String>().having(
+              (s) => s, 'error', contains('No type invalid_type exists'))));
+    });
+
+    test('eventName returns correct string', () {
+      expect(ChannelEvents.close.eventName(), 'phx_close');
+      expect(ChannelEvents.error.eventName(), 'phx_error');
+      expect(ChannelEvents.join.eventName(), 'phx_join');
+      expect(ChannelEvents.reply.eventName(), 'phx_reply');
+      expect(ChannelEvents.leave.eventName(), 'phx_leave');
+      expect(ChannelEvents.heartbeat.eventName(), 'phx_heartbeat');
+      expect(ChannelEvents.accessToken.eventName(), 'access_token');
+      expect(ChannelEvents.postgresChanges.eventName(), 'postgres_changes');
+      expect(ChannelEvents.broadcast.eventName(), 'broadcast');
+      expect(ChannelEvents.presence.eventName(), 'presence');
+    });
+  });
+
+  group('Transports', () {
+    test('has correct websocket value', () {
+      expect(Transports.websocket, 'websocket');
+    });
+  });
+
+  group('RealtimeLogLevel', () {
+    test('enum values exist', () {
+      expect(RealtimeLogLevel.info, isNotNull);
+      expect(RealtimeLogLevel.debug, isNotNull);
+      expect(RealtimeLogLevel.warn, isNotNull);
+      expect(RealtimeLogLevel.error, isNotNull);
+    });
+  });
+}