Melo/test/library/suche_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:melo/library/database.dart';
import 'package:melo/library/suche.dart';

Song _song(String titel, {String? kuenstler, String? album, String? id}) => Song(
      id: id ?? titel.toLowerCase().replaceAll(' ', '-'),
      path: '/music/$titel.mp3',
      title: titel,
      artist: kuenstler,
      album: album,
      dateAddedMs: 0,
      updatedAtMs: 0,
      deleted: false,
      playCount: 0,
      categoriesEdited: false,
      metadataEdited: false,
    );

Playlist _liste(String name) => Playlist(
      id: name.toLowerCase(),
      name: name,
      createdAtMs: 0,
      updatedAtMs: 0,
      deleted: false,
    );

SuchTreffer _suche(
  String query, {
  List<Song>? songs,
  List<String>? kategorien,
  List<Playlist>? playlisten,
}) =>
    sucheLokal(
      songs: songs ?? const [],
      kategorien: kategorien ?? const [],
      playlisten: playlisten ?? const [],
      query: query,
    );

void main() {
  group('leere Eingabe', () {
    test('findet nichts', () {
      final treffer = _suche('', songs: [_song('Roses')]);

      expect(treffer.istLeer, isTrue);
    });

    test('nur Leerzeichen zählen als leer', () {
      final treffer = _suche('   ', songs: [_song('Roses')]);

      expect(treffer.istLeer, isTrue);
    });
  });

  group('Titel', () {
    final songs = [
      _song('Roses', kuenstler: 'Neoni', album: 'Trailerpark'),
      _song('Demons', kuenstler: 'Nightcore'),
      _song('Wild Roses', kuenstler: 'Lori'),
    ];

    test('findet über den Titel', () {
      expect(_suche('demons', songs: songs).titel.map((s) => s.title),
          ['Demons']);
    });

    test('findet über den Künstler', () {
      expect(_suche('neoni', songs: songs).titel.map((s) => s.title),
          ['Roses']);
    });

    test('findet über das Album', () {
      expect(_suche('trailerpark', songs: songs).titel.map((s) => s.title),
          ['Roses']);
    });

    test('ignoriert Groß- und Kleinschreibung', () {
      expect(_suche('ROSES', songs: songs).titel.length, 2);
    });

    test('Treffer am Wortanfang stehen vorn', () {
      // "Roses" beginnt mit der Eingabe, "Wild Roses" enthält sie nur.
      expect(_suche('roses', songs: songs).titel.map((s) => s.title),
          ['Roses', 'Wild Roses']);
    });

    test('ein Titel erscheint nur einmal, auch wenn mehrere Felder passen', () {
      final doppelt = [_song('Neoni', kuenstler: 'Neoni', album: 'Neoni')];

      expect(_suche('neoni', songs: doppelt).titel.length, 1);
    });
  });

  group('Künstler', () {
    final songs = [
      _song('A', kuenstler: 'Nightcore Gaming'),
      _song('B', kuenstler: 'Nightcore Gaming'),
      _song('C', kuenstler: 'Anime Nightcore'),
      _song('D', kuenstler: 'Neoni'),
      _song('E'),
    ];

    test('nennt jeden Künstler nur einmal', () {
      expect(_suche('nightcore', songs: songs).kuenstler,
          ['Nightcore Gaming', 'Anime Nightcore']);
    });

    test('Treffer am Wortanfang stehen vorn', () {
      expect(_suche('nightcore', songs: songs).kuenstler.first,
          'Nightcore Gaming');
    });

    test('Titel ohne Künstler erzeugen keinen leeren Eintrag', () {
      expect(_suche('e', songs: songs).kuenstler, isNot(contains('')));
    });
  });

  group('Kategorien', () {
    const kategorien = ['Trap cool', 'Trap neu', 'Nightcore', 'Rock'];

    test('findet passende Kategorien', () {
      expect(_suche('trap', kategorien: kategorien).kategorien,
          ['Trap cool', 'Trap neu']);
    });

    test('findet nichts Unpassendes', () {
      expect(_suche('jazz', kategorien: kategorien).kategorien, isEmpty);
    });
  });

  group('Wiedergabelisten', () {
    final listen = [_liste('Sport'), _liste('Sonntagmorgen')];

    test('findet über den Namen', () {
      expect(_suche('sonn', playlisten: listen).playlisten.map((p) => p.name),
          ['Sonntagmorgen']);
    });
  });

  group('Zusammenspiel', () {
    test('zählt alle Abschnitte zusammen', () {
      final treffer = _suche(
        'rock',
        songs: [_song('Rock Anthem', kuenstler: 'Rocker')],
        kategorien: ['Rock'],
        playlisten: [_liste('Rock-Liste')],
      );

      expect(treffer.titel.map((s) => s.title), ['Rock Anthem']);
      expect(treffer.kuenstler, ['Rocker']);
      expect(treffer.kategorien, ['Rock']);
      expect(treffer.playlisten.map((p) => p.name), ['Rock-Liste']);
      expect(treffer.istLeer, isFalse);
    });

    test('ohne Treffer ist das Ergebnis leer, nicht null', () {
      final treffer = _suche('gibtesnicht', songs: [_song('Roses')]);

      expect(treffer.istLeer, isTrue);
      expect(treffer.titel, isEmpty);
      expect(treffer.kuenstler, isEmpty);
    });
  });

  group('kuenstlerNachSchluessel', () {
    test('fasst Schreibweisen zusammen, wie es die Suche tut', () {
      // Genau der Bruch, der "0 Titel" und einen leeren Bildschirm ergab:
      // die Suche nannte einen Künstler, die Zuordnung fand ihn nicht.
      final gebuendelt = kuenstlerNachSchluessel([
        _song('A', kuenstler: 'Neoni'),
        _song('B', kuenstler: 'NEONI'),
        _song('C', kuenstler: 'Neoni '),
      ]);

      expect(gebuendelt.keys, ['neoni']);
      expect(gebuendelt['neoni']!.length, 3);
    });

    test('der Treffer der Suche findet seine Titel wieder', () {
      final songs = [_song('A', kuenstler: 'Neoni '), _song('B', kuenstler: 'NEONI')];
      final treffer = sucheLokal(
          songs: songs, kategorien: const [], playlisten: const [], query: 'neoni');
      final gebuendelt = kuenstlerNachSchluessel(songs);

      final name = treffer.kuenstler.single;
      expect(gebuendelt[suchSchluessel(name)]!.length, 2);
    });

    test('Titel ohne Künstler kommen nicht vor', () {
      expect(kuenstlerNachSchluessel([_song('A'), _song('B', kuenstler: '  ')]),
          isEmpty);
    });
  });

  group('kategorienNachSchluessel', () {
    test('fasst Schreibweisen zusammen', () {
      final a = _song('A', id: 'a');
      final b = _song('B', id: 'b');
      final gebuendelt = kategorienNachSchluessel(
        [a, b],
        (s) => s.id == 'a' ? ['Rock'] : ['rock'],
      );

      expect(gebuendelt.keys, ['rock']);
      expect(gebuendelt['rock']!.length, 2);
    });

    test('ein Titel steht unter jeder seiner Kategorien', () {
      final gebuendelt = kategorienNachSchluessel(
        [_song('A')],
        (_) => ['Rock', 'Chill'],
      );

      expect(gebuendelt.keys.toSet(), {'rock', 'chill'});
    });

    test('leere Kategorienamen werden übergangen', () {
      expect(kategorienNachSchluessel([_song('A')], (_) => ['  ']), isEmpty);
    });
  });

  group('suchSchluessel', () {
    test('trimmt und senkt die Schreibweise', () {
      expect(suchSchluessel('  NEONI '), 'neoni');
    });
  });
}