plezy/test/connection/connection_models_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:plezy/connection/connection.dart';
import 'package:plezy/media/media_backend.dart';
import 'package:plezy/media/media_browser_dialect.dart';

/// Backend-agnostic [Connection] sealed-class tests. The
/// `connection_registry_test` already covers DB persistence; these focus on
/// the model layer's `toConfigJson` / `fromConfigJson` round-trip and the
/// derived `kind` / `backend` mappings — the bits the registry treats as a
/// black box.
void main() {
  group('ConnectionKind', () {
    test('id round-trips through fromId', () {
      for (final k in ConnectionKind.values) {
        expect(ConnectionKind.fromId(k.id), k);
      }
    });

    test('fromId throws on unknown id (no silent fallback)', () {
      expect(() => ConnectionKind.fromId('kodi'), throwsA(isA<ArgumentError>()));
    });

    test('backend mapping is total', () {
      expect(ConnectionKind.plex.backend, MediaBackend.plex);
      expect(ConnectionKind.jellyfin.backend, MediaBackend.jellyfin);
      expect(ConnectionKind.emby.backend, MediaBackend.emby);
    });

    test('dialect maps only the MediaBrowser kinds and round-trips', () {
      expect(ConnectionKind.plex.dialect, isNull);
      expect(ConnectionKind.jellyfin.dialect, MediaBrowserDialect.jellyfin);
      expect(ConnectionKind.emby.dialect, MediaBrowserDialect.emby);
      for (final dialect in MediaBrowserDialect.values) {
        expect(ConnectionKind.fromDialect(dialect).dialect, dialect);
      }
    });
  });

  group('JellyfinConnection serialization', () {
    final base = JellyfinConnection(
      id: 'srv-1/user-1',
      baseUrl: 'https://jellyfin.example.com',
      baseUrls: const ['https://jellyfin.example.com', 'https://jellyfin.lan:8096'],
      serverName: 'Home',
      serverMachineId: 'srv-1',
      userId: 'user-1',
      userName: 'edde',
      accessToken: 'tok-abc',
      deviceId: 'dev-xyz',
      createdAt: DateTime.utc(2026, 1, 15),
      lastAuthenticatedAt: DateTime.utc(2026, 4, 25),
    );

    test('toConfigJson + fromConfigJson round-trip preserves every field', () {
      final json = base.toConfigJson();
      final restored = JellyfinConnection.fromConfigJson(
        id: base.id,
        json: json,
        status: base.status,
        createdAt: base.createdAt,
        lastAuthenticatedAt: base.lastAuthenticatedAt,
      );
      expect(restored.id, base.id);
      expect(restored.baseUrl, base.baseUrl);
      expect(restored.baseUrls, base.baseUrls);
      expect(restored.serverName, base.serverName);
      expect(restored.serverMachineId, base.serverMachineId);
      expect(restored.userId, base.userId);
      expect(restored.userName, base.userName);
      expect(restored.accessToken, base.accessToken);
      expect(restored.deviceId, base.deviceId);
      expect(restored.createdAt, base.createdAt);
      expect(restored.lastAuthenticatedAt, base.lastAuthenticatedAt);
    });

    test('primary image tag round-trips through config JSON', () {
      final tagged = base.copyWith(primaryImageTag: 'avatar-tag');
      final restored = JellyfinConnection.fromConfigJson(
        id: tagged.id,
        json: tagged.toConfigJson(),
        status: tagged.status,
        createdAt: tagged.createdAt,
        lastAuthenticatedAt: tagged.lastAuthenticatedAt,
      );

      expect(restored.primaryImageTag, 'avatar-tag');
    });

    test('config saved before image tags decodes with no primary image tag', () {
      final legacyJson = <String, Object?>{
        'baseUrl': base.baseUrl,
        'baseUrls': base.baseUrls,
        'serverName': base.serverName,
        'serverMachineId': base.serverMachineId,
        'userId': base.userId,
        'userName': base.userName,
        'accessToken': base.accessToken,
        'deviceId': base.deviceId,
        'isAdministrator': base.isAdministrator,
      };
      expect(legacyJson.containsKey('primaryImageTag'), isFalse);

      final restored = JellyfinConnection.fromConfigJson(
        id: base.id,
        json: legacyJson,
        status: base.status,
        createdAt: base.createdAt,
        lastAuthenticatedAt: base.lastAuthenticatedAt,
      );

      expect(restored.primaryImageTag, isNull);
    });

    test('blank persisted primary image tags decode as null', () {
      for (final tag in ['', ' \t\n ']) {
        final restored = JellyfinConnection.fromConfigJson(
          id: base.id,
          json: {...base.toConfigJson(), 'primaryImageTag': tag},
          status: base.status,
          createdAt: base.createdAt,
          lastAuthenticatedAt: base.lastAuthenticatedAt,
        );

        expect(restored.primaryImageTag, isNull, reason: 'tag: "$tag"');
      }
    });

    test('fromConfigJson with empty payload uses safe defaults (no NPE)', () {
      final restored = JellyfinConnection.fromConfigJson(
        id: 'orphan',
        json: const {},
        status: ConnectionStatus.unknown,
        createdAt: DateTime.utc(2026),
      );
      expect(restored.id, 'orphan');
      expect(restored.baseUrl, '');
      expect(restored.baseUrls, isEmpty);
      expect(restored.serverName, 'Jellyfin');
      expect(restored.accessToken, '');
    });

    test('fromConfigJson backfills baseUrls from legacy baseUrl', () {
      final restored = JellyfinConnection.fromConfigJson(
        id: 'legacy',
        json: const {
          'baseUrl': 'https://jellyfin.example.com',
          'serverName': 'Home',
          'serverMachineId': 'srv-1',
          'userId': 'user-1',
        },
        status: ConnectionStatus.unknown,
        createdAt: DateTime.utc(2026),
      );

      expect(restored.baseUrl, 'https://jellyfin.example.com');
      expect(restored.baseUrls, ['https://jellyfin.example.com']);
    });

    test('copyWith moves the active baseUrl to the front of baseUrls', () {
      final updated = base.copyWith(baseUrl: 'https://jellyfin.lan:8096');
      expect(updated.baseUrl, 'https://jellyfin.lan:8096');
      expect(updated.baseUrls, ['https://jellyfin.lan:8096', 'https://jellyfin.example.com']);
    });

    test('copyWith preserves an existing primary image tag by default', () {
      final tagged = base.copyWith(primaryImageTag: 'old');

      expect(tagged.copyWith().primaryImageTag, 'old');
    });

    test('copyWith replaces an existing primary image tag', () {
      final tagged = base.copyWith(primaryImageTag: 'old');

      expect(tagged.copyWith(primaryImageTag: 'new').primaryImageTag, 'new');
    });

    test('copyWith only clears a primary image tag through the clear sentinel', () {
      final tagged = base.copyWith(primaryImageTag: 'old');

      expect(tagged.copyWith(primaryImageTag: null).primaryImageTag, 'old');
      expect(tagged.copyWith(clearPrimaryImageTag: true).primaryImageTag, isNull);
    });

    test('reads primary image tags defensively from Jellyfin user DTOs', () {
      expect(JellyfinConnection.readPrimaryImageTag(const {'PrimaryImageTag': 'avatar-tag'}), 'avatar-tag');
      expect(JellyfinConnection.readPrimaryImageTag(const {}), isNull);
      expect(JellyfinConnection.readPrimaryImageTag(const {'PrimaryImageTag': ' \t\n '}), isNull);
      expect(JellyfinConnection.readPrimaryImageTag(const {'PrimaryImageTag': 42}), '42');
    });

    test('kind and backend match Jellyfin', () {
      expect(base.dialect, MediaBrowserDialect.jellyfin);
      expect(base.kind, ConnectionKind.jellyfin);
      expect(base.backend, MediaBackend.jellyfin);
    });

    test('an Emby dialect drives kind, backend and the persisted discriminator', () {
      final emby = base.copyWith(dialect: MediaBrowserDialect.emby);

      expect(emby.kind, ConnectionKind.emby);
      expect(emby.kind.id, 'emby');
      expect(emby.backend, MediaBackend.emby);
      // The dialect lives in the `connections.kind` column, never in the
      // encrypted config payload, so exactly one discriminator is on disk.
      expect(emby.toConfigJson().containsKey('dialect'), isFalse);
    });

    test('fromConfigJson restores the dialect handed in by the registry', () {
      final restored = JellyfinConnection.fromConfigJson(
        id: 'srv-1/user-1',
        json: base.toConfigJson(),
        status: ConnectionStatus.online,
        createdAt: base.createdAt,
        dialect: MediaBrowserDialect.emby,
      );

      expect(restored.dialect, MediaBrowserDialect.emby);
      expect(restored.kind, ConnectionKind.emby);
      expect(restored.accessToken, 'tok-abc');
    });

    test('fromConfigJson defaults to Jellyfin for rows written before Emby support', () {
      final restored = JellyfinConnection.fromConfigJson(
        id: 'legacy',
        json: const {'baseUrl': 'https://jellyfin.example.com'},
        status: ConnectionStatus.unknown,
        createdAt: DateTime.utc(2026),
      );

      expect(restored.dialect, MediaBrowserDialect.jellyfin);
      expect(restored.kind, ConnectionKind.jellyfin);
    });

    test('empty-payload serverName falls back to the dialect product name', () {
      final emby = JellyfinConnection.fromConfigJson(
        id: 'orphan',
        json: const {},
        status: ConnectionStatus.unknown,
        createdAt: DateTime.utc(2026),
        dialect: MediaBrowserDialect.emby,
      );

      expect(emby.serverName, 'Emby');
    });
  });

  group('PlexAccountConnection serialization', () {
    final base = PlexAccountConnection(
      id: 'plex.client-uuid',
      accountToken: 'token-xyz',
      clientIdentifier: 'client-uuid',
      accountLabel: 'edde',
      servers: const [],
      activeProfile: null,
      createdAt: DateTime.utc(2026, 1, 15),
      lastAuthenticatedAt: DateTime.utc(2026, 4, 25),
    );

    test('toConfigJson + fromConfigJson round-trip preserves identity fields', () {
      final json = base.toConfigJson();
      final restored = PlexAccountConnection.fromConfigJson(
        id: base.id,
        json: json,
        status: base.status,
        createdAt: base.createdAt,
        lastAuthenticatedAt: base.lastAuthenticatedAt,
      );
      expect(restored.id, base.id);
      expect(restored.accountToken, base.accountToken);
      expect(restored.clientIdentifier, base.clientIdentifier);
      expect(restored.accountLabel, base.accountLabel);
      expect(restored.servers, isEmpty);
      expect(restored.activeProfile, isNull);
      expect(restored.createdAt, base.createdAt);
      expect(restored.lastAuthenticatedAt, base.lastAuthenticatedAt);
    });

    test('fromConfigJson with empty payload uses safe defaults (no NPE)', () {
      final restored = PlexAccountConnection.fromConfigJson(
        id: 'orphan',
        json: const {},
        status: ConnectionStatus.unknown,
        createdAt: DateTime.utc(2026),
      );
      expect(restored.id, 'orphan');
      expect(restored.accountToken, '');
      expect(restored.accountLabel, 'Plex');
      expect(restored.servers, isEmpty);
    });

    test('kind and backend match Plex', () {
      expect(base.kind, ConnectionKind.plex);
      expect(base.backend, MediaBackend.plex);
    });
  });
}