ScarriffleandClaude Opus 5
8b67a7ec88
Vorher räumte der Scan jede Datei weg, die er nicht mehr sah, und mit der letzten Datei fiel der Titel samt Sehfortschritt aller Benutzer. Für eine wirklich gelöschte Datei ist das richtig. Für eine Platte im Ruhezustand, ein noch nicht eingehängtes Volume oder einen umbenannten Ordner ist es Datenverlust — und für den Scan sehen alle vier Fälle gleich aus. Jetzt trägt MediaFile ein MissingSince. Der Eintrag bleibt stehen, steht in der Verwaltung unter "Nicht mehr gefunden", und gelöscht wird auf Ansage. Taucht die Datei wieder auf, verschwindet die Markierung von selbst. Dazu die Notbremse, und sie ist der eigentliche Grund für den ganzen Punkt: Fehlt der Wurzelpfad, oder liegt dort keine einzige Mediendatei mehr, obwohl vorher welche da waren, bricht der Lauf ab und sagt warum. Ohne sie erklärte ein nicht eingehängtes Volume beim Start des NAS den gesamten Bestand für verschwunden — bei 458 Titeln. Der Abschnitt in der Verwaltung erscheint nur, wenn es etwas zu melden gibt. Ein dauerhaft leerer wäre Rauschen. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
434 lines
18 KiB
C#
434 lines
18 KiB
C#
using System.Net;
|
||
using System.Net.Http.Json;
|
||
using Flaro.Api.Endpoints;
|
||
|
||
namespace Flaro.Api.Tests;
|
||
|
||
/// <summary>Scan gegen einen echten Ordner mit echten Dateien.</summary>
|
||
public class ScanTests
|
||
{
|
||
private string _bestand = "";
|
||
|
||
[SetUp]
|
||
public void Anlegen() => _bestand = Directory.CreateDirectory(
|
||
Path.Combine(Path.GetTempPath(), "flaro-medien-" + Guid.CreateVersion7().ToString("N"))).FullName;
|
||
|
||
[TearDown]
|
||
public void Aufraeumen()
|
||
{
|
||
try { Directory.Delete(_bestand, recursive: true); } catch (IOException) { }
|
||
}
|
||
|
||
private void Datei(string relativ, int bytes = 2048)
|
||
{
|
||
var voll = Path.Combine(_bestand, relativ);
|
||
Directory.CreateDirectory(Path.GetDirectoryName(voll)!);
|
||
File.WriteAllBytes(voll, new byte[bytes]);
|
||
}
|
||
|
||
private async Task<(HttpClient Admin, Guid LibraryId)> MitBibliothek(FlaroServer server, string art)
|
||
{
|
||
var admin = await server.SetUpAndSignIn();
|
||
var client = server.AlsAngemeldeter(admin.Token);
|
||
var angelegt = await client.PostAsJsonAsync("/api/v1/libraries",
|
||
new CreateLibraryRequest("Prüfbestand", art, _bestand));
|
||
angelegt.EnsureSuccessStatusCode();
|
||
var bibliothek = (await angelegt.Content.ReadFromJsonAsync<LibraryResponse>())!;
|
||
return (client, bibliothek.Id);
|
||
}
|
||
|
||
/// <summary>Stösst an und wartet, bis der Hintergrundlauf fertig ist.</summary>
|
||
private static async Task<ScanStatus> Scannen(HttpClient client, Guid bibliothek)
|
||
{
|
||
var angestossen = await client.PostAsync($"/api/v1/libraries/{bibliothek}/scan", null);
|
||
Assert.That(angestossen.StatusCode, Is.EqualTo(HttpStatusCode.Accepted));
|
||
|
||
// **Dreissig Sekunden, nicht fünf.** Die alte Grenze war für zwei,
|
||
// drei Dateien bemessen. Der Test über 120 Dateien schaffte sie
|
||
// allein, fiel aber durch, sobald die ganze Suite nebenher lief —
|
||
// und das war kein Fehler im Scan, sondern eine zu knappe Geduld.
|
||
// Teurer wird es nur, wenn wirklich etwas hängt.
|
||
const int schritte = 600, abstand = 50;
|
||
|
||
for (var versuch = 0; versuch < schritte; versuch++)
|
||
{
|
||
var stand = await client.GetFromJsonAsync<ScanStatus>($"/api/v1/libraries/{bibliothek}/scan");
|
||
if (stand!.State is "finished") return stand;
|
||
if (stand.State is "failed") Assert.Fail($"Der Scan ist gescheitert: {stand.Error}");
|
||
await Task.Delay(abstand);
|
||
}
|
||
Assert.Fail($"Der Scan wurde in {schritte * abstand / 1000} Sekunden nicht fertig.");
|
||
return null!;
|
||
}
|
||
|
||
[Test]
|
||
public async Task Filme_werden_gefunden_und_benannt()
|
||
{
|
||
Datei("The.Matrix.1999.1080p.BluRay.x264-GRP.mkv");
|
||
Datei("Der Untergang (2004).mkv");
|
||
Datei("The Matrix (1999).srt"); // zählt nicht
|
||
Datei("@eaDir/The.Matrix.1999.mkv"); // zählt auch nicht
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
|
||
var stand = await Scannen(client, bibliothek);
|
||
Assert.That(stand.FilesFound, Is.EqualTo(2));
|
||
Assert.That(stand.Added, Is.EqualTo(2));
|
||
|
||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||
Assert.That(filme!.Total, Is.EqualTo(2));
|
||
// Sortiert ohne Artikel: „Matrix" vor „Untergang".
|
||
Assert.That(filme.Items.Select(m => m.Title),
|
||
Is.EqualTo(new[] { "The Matrix", "Der Untergang" }));
|
||
Assert.That(filme.Items[0].Year, Is.EqualTo(1999));
|
||
}
|
||
|
||
/// <summary>Zweimal scannen muss dasselbe ergeben wie einmal.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Sonst wächst die Mediathek bei jedem Lauf.</b> Das ist der Fehler,
|
||
/// den man erst nach Wochen bemerkt — wenn jeder Film fünfmal dasteht.
|
||
/// </remarks>
|
||
[Test]
|
||
public async Task Ein_zweiter_Lauf_aendert_nichts()
|
||
{
|
||
Datei("The Matrix (1999).mkv");
|
||
Datei("Inception (2010).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
|
||
await Scannen(client, bibliothek);
|
||
var zweiter = await Scannen(client, bibliothek);
|
||
|
||
Assert.That(zweiter.Added, Is.EqualTo(0));
|
||
Assert.That(zweiter.Removed, Is.EqualTo(0));
|
||
Assert.That((await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies"))!.Total, Is.EqualTo(2));
|
||
}
|
||
|
||
/// <summary>Eine verschwundene Datei wird gemeldet, nicht stillschweigend gelöscht.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Vorher fiel hier der Titel samt Sehfortschritt.</b> Das ist für eine
|
||
/// wirklich gelöschte Datei richtig — und falsch für jeden anderen Grund,
|
||
/// aus dem eine Datei kurz nicht da ist. Beides sieht für den Scan gleich
|
||
/// aus, also entscheidet jetzt der Administrator.
|
||
/// </remarks>
|
||
[Test]
|
||
public async Task Eine_verschwundene_Datei_wird_gemeldet_statt_geloescht()
|
||
{
|
||
Datei("The Matrix (1999).mkv");
|
||
Datei("Inception (2010).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
File.Delete(Path.Combine(_bestand, "Inception (2010).mkv"));
|
||
var danach = await Scannen(client, bibliothek);
|
||
|
||
Assert.That(danach.Missing, Is.EqualTo(1));
|
||
Assert.That((await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies"))!.Total,
|
||
Is.EqualTo(2), "Der Titel bleibt stehen, bis jemand ihn entfernt.");
|
||
|
||
var vermisst = await client.GetFromJsonAsync<List<VermissteDatei>>("/api/v1/libraries/missing");
|
||
Assert.That(vermisst, Has.Count.EqualTo(1));
|
||
Assert.That(vermisst![0].Title, Is.EqualTo("Inception"));
|
||
|
||
// Und erst auf Ansage ist er wirklich weg.
|
||
(await client.DeleteAsync("/api/v1/libraries/missing")).EnsureSuccessStatusCode();
|
||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||
Assert.That(filme!.Items.Select(m => m.Title), Is.EqualTo(new[] { "The Matrix" }));
|
||
}
|
||
|
||
/// <summary>Kommt die Datei zurück, verschwindet die Markierung von selbst.</summary>
|
||
[Test]
|
||
public async Task Eine_zurueckgekehrte_Datei_gilt_wieder_als_da()
|
||
{
|
||
// Zwei Dateien, damit der Ordner nicht leer wird — sonst greift die
|
||
// Notbremse aus dem Test darunter, und zwar zu Recht.
|
||
Datei("Inception (2010).mkv");
|
||
Datei("The Matrix (1999).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var pfad = Path.Combine(_bestand, "Inception (2010).mkv");
|
||
var inhalt = await File.ReadAllBytesAsync(pfad);
|
||
File.Delete(pfad);
|
||
await Scannen(client, bibliothek);
|
||
Assert.That(await client.GetFromJsonAsync<List<VermissteDatei>>("/api/v1/libraries/missing"),
|
||
Has.Count.EqualTo(1));
|
||
|
||
await File.WriteAllBytesAsync(pfad, inhalt);
|
||
await Scannen(client, bibliothek);
|
||
|
||
Assert.That(await client.GetFromJsonAsync<List<VermissteDatei>>("/api/v1/libraries/missing"),
|
||
Is.Empty);
|
||
}
|
||
|
||
/// <summary>Die Notbremse: ein leerer Ordner bricht ab, statt alles zu verwerfen.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Der teuerste denkbare Fehler.</b> Ist das Volume beim Start des NAS
|
||
/// noch nicht eingehängt, liegt der Ordner leer da — und ohne diese Prüfung
|
||
/// gälte der gesamte Bestand als verschwunden.
|
||
/// </remarks>
|
||
[Test]
|
||
public async Task Ein_ploetzlich_leerer_Ordner_bricht_den_Scan_ab()
|
||
{
|
||
Datei("The Matrix (1999).mkv");
|
||
Datei("Inception (2010).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
foreach (var d in Directory.EnumerateFiles(_bestand, "*", SearchOption.AllDirectories))
|
||
File.Delete(d);
|
||
|
||
var angestossen = await client.PostAsync($"/api/v1/libraries/{bibliothek}/scan", null);
|
||
Assert.That(angestossen.StatusCode, Is.EqualTo(HttpStatusCode.Accepted));
|
||
|
||
ScanStatus? stand = null;
|
||
for (var versuch = 0; versuch < 600; versuch++)
|
||
{
|
||
stand = await client.GetFromJsonAsync<ScanStatus>($"/api/v1/libraries/{bibliothek}/scan");
|
||
if (stand!.State is "failed" or "finished") break;
|
||
await Task.Delay(50);
|
||
}
|
||
|
||
Assert.That(stand!.State, Is.EqualTo("failed"));
|
||
Assert.That(stand.Error, Does.Contain("abgebrochen"));
|
||
Assert.That((await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies"))!.Total,
|
||
Is.EqualTo(2), "Es darf nichts verändert worden sein.");
|
||
Assert.That(await client.GetFromJsonAsync<List<VermissteDatei>>("/api/v1/libraries/missing"),
|
||
Is.Empty, "Auch nicht als vermisst markiert.");
|
||
}
|
||
|
||
/// <summary>Das Aufräumen darf nicht wegräumen, was derselbe Lauf schrieb.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Mehr als fünfzig Dateien, und das ist der Punkt.</b> Seit der Scan
|
||
/// alle fünfzig Dateien zwischenspeichert, liegt ein Teil des Bestands
|
||
/// schon in der Datenbank, während der Lauf noch läuft. Direkt danach
|
||
/// löscht er alles, was eine ältere <c>SeenAt</c>-Zeit trägt als dieser
|
||
/// Lauf — würde die Zeit irgendwo neu genommen statt vor der Schleife
|
||
/// festgehalten, risse dieser Schritt den halben Bestand mit.
|
||
///
|
||
/// Die Dateien hier sind Nullbytes, an denen ffprobe scheitert. Damit
|
||
/// greift das Zwischenspeichern aus der Schleife und nicht das aus der
|
||
/// Untersuchung — also genau der Weg, der sonst ungeprüft bliebe.
|
||
/// </remarks>
|
||
[Test]
|
||
public async Task Ein_grosser_Bestand_ueberlebt_das_Aufraeumen()
|
||
{
|
||
for (var i = 1; i <= 120; i++) Datei($"Prüffilm {i:000} (2024).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
|
||
var erster = await Scannen(client, bibliothek);
|
||
|
||
Assert.That(erster.Added, Is.EqualTo(120));
|
||
Assert.That(erster.Removed, Is.Zero, "Ein erster Lauf darf nichts entfernen.");
|
||
Assert.That((await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies"))!.Total,
|
||
Is.EqualTo(120));
|
||
|
||
// Und ein zweiter Lauf bleibt ebenso vollständig.
|
||
var zweiter = await Scannen(client, bibliothek);
|
||
Assert.That(zweiter.Removed, Is.Zero);
|
||
Assert.That((await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies"))!.Total,
|
||
Is.EqualTo(120));
|
||
}
|
||
|
||
/// <summary>Schreibvarianten desselben Titels ergeben einen Eintrag.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Der Fall, der die Mediathek doppelt aussehen liess.</b> Der Scan
|
||
/// verglich den Titel aus dem Dateinamen zeichengenau — ein Punkt
|
||
/// Unterschied, und es wurden zwei Filme, die anschliessend beide
|
||
/// denselben TMDB-Eintrag bekamen und ununterscheidbar nebeneinander
|
||
/// standen.
|
||
/// </remarks>
|
||
[Test]
|
||
public async Task Schreibvarianten_ergeben_einen_Film()
|
||
{
|
||
Datei("Dr. Dolittle 2 (2001).mkv");
|
||
Datei("Dr Dolittle 2.mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||
Assert.That(filme!.Total, Is.EqualTo(1));
|
||
Assert.That(filme.Items[0].Files, Has.Count.EqualTo(2));
|
||
Assert.That(filme.Items[0].Year, Is.EqualTo(2001),
|
||
"Das Jahr der einen Datei gilt auch, wenn die andere keines trägt.");
|
||
}
|
||
|
||
/// <summary>Eine mobile Fassung ist kein eigener Film.</summary>
|
||
[Test]
|
||
public async Task Eine_optimierte_Fassung_bleibt_beim_Film()
|
||
{
|
||
Datei("The Matrix (1999).mkv");
|
||
Datei("The Matrix (1999) - Mobil.mp4");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||
Assert.That(filme!.Total, Is.EqualTo(1), "Sonst stünde ein zweiter Film ‚The Matrix - Mobil‘ daneben.");
|
||
Assert.That(filme.Items[0].Title, Is.EqualTo("The Matrix"));
|
||
Assert.That(filme.Items[0].Files, Has.Count.EqualTo(2));
|
||
}
|
||
|
||
/// <summary>Gleicher Name, anderes Jahr — zwei Filme, und das muss so bleiben.</summary>
|
||
[Test]
|
||
public async Task Zwei_Verfilmungen_bleiben_zwei_Filme()
|
||
{
|
||
Datei("Dune (1984).mkv");
|
||
Datei("Dune (2021).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||
Assert.That(filme!.Total, Is.EqualTo(2));
|
||
}
|
||
|
||
/// <summary>4K und 1080p sind ein Film mit zwei Dateien, nicht zwei Filme.</summary>
|
||
[Test]
|
||
public async Task Zwei_Fassungen_desselben_Films_bleiben_ein_Eintrag()
|
||
{
|
||
Datei("The Matrix (1999) - 1080p.mkv");
|
||
Datei("The Matrix (1999) - 2160p.mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||
Assert.That(filme!.Total, Is.EqualTo(1));
|
||
Assert.That(filme.Items[0].Files, Has.Count.EqualTo(2));
|
||
}
|
||
|
||
[Test]
|
||
public async Task Serien_werden_in_Staffeln_und_Folgen_zerlegt()
|
||
{
|
||
Datei("Dark/Staffel 1/Dark - S01E01 - Geheimnisse.mkv");
|
||
Datei("Dark/Staffel 1/Dark - S01E02 - Lügen.mkv");
|
||
Datei("Dark/Staffel 2/Dark - S02E01 - Anfänge.mkv");
|
||
Datei("Notruf.Hafenkante.S01E01.German.1080p.mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Shows");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var serien = await client.GetFromJsonAsync<Page<SeriesResponse>>("/api/v1/series");
|
||
Assert.That(serien!.Total, Is.EqualTo(2));
|
||
|
||
var dark = serien.Items.Single(s => s.Title == "Dark");
|
||
Assert.That(dark.EpisodeCount, Is.EqualTo(3));
|
||
Assert.That(dark.Seasons, Is.EqualTo(new[] { 1, 2 }));
|
||
|
||
var folgen = await client.GetFromJsonAsync<Page<EpisodeResponse>>($"/api/v1/series/{dark.Id}/episodes");
|
||
Assert.That(folgen!.Items.Select(f => f.Title),
|
||
Is.EqualTo(new[] { "Geheimnisse", "Lügen", "Anfänge" }));
|
||
|
||
var nurStaffel2 = await client.GetFromJsonAsync<Page<EpisodeResponse>>(
|
||
$"/api/v1/series/{dark.Id}/episodes?season=2");
|
||
Assert.That(nurStaffel2!.Items, Has.Count.EqualTo(1));
|
||
}
|
||
|
||
/// <summary>Was keine Folgennummer trägt, wird nicht geraten.</summary>
|
||
[Test]
|
||
public async Task Dateien_ohne_Folgennummer_werden_gezaehlt_aber_nicht_zugeordnet()
|
||
{
|
||
Datei("Dark/Dark - S01E01.mkv");
|
||
Datei("Dark/Irgendein Mitschnitt.mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Shows");
|
||
var stand = await Scannen(client, bibliothek);
|
||
|
||
Assert.That(stand.FilesFound, Is.EqualTo(2));
|
||
Assert.That(stand.Unrecognised, Is.EqualTo(1));
|
||
Assert.That(stand.Added, Is.EqualTo(1));
|
||
}
|
||
|
||
[Test]
|
||
public async Task Die_Suche_grenzt_ein()
|
||
{
|
||
Datei("The Matrix (1999).mkv");
|
||
Datei("The Matrix Reloaded (2003).mkv");
|
||
Datei("Inception (2010).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var treffer = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies?search=matrix");
|
||
Assert.That(treffer!.Total, Is.EqualTo(2));
|
||
}
|
||
|
||
/// <summary>Eine Anfrage darf sich die Seitengrösse nicht selbst aussuchen.</summary>
|
||
[Test]
|
||
public async Task Die_Seitengroesse_ist_gedeckelt()
|
||
{
|
||
for (var i = 1; i <= 5; i++) Datei($"Film {i} (200{i}).mkv");
|
||
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await Scannen(client, bibliothek);
|
||
|
||
var seite = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies?take=100000");
|
||
Assert.That(seite!.Total, Is.EqualTo(5), "Die Gesamtzahl bleibt richtig");
|
||
Assert.That(seite.Items, Has.Count.LessThanOrEqualTo(200));
|
||
|
||
var zweiteSeite = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies?skip=2&take=2");
|
||
Assert.That(zweiteSeite!.Items, Has.Count.EqualTo(2));
|
||
Assert.That(zweiteSeite.Total, Is.EqualTo(5));
|
||
}
|
||
|
||
[Test]
|
||
public async Task Vor_dem_ersten_Lauf_steht_der_Scan_auf_untaetig()
|
||
{
|
||
using var server = new FlaroServer();
|
||
var (client, bibliothek) = await MitBibliothek(server, "Movies");
|
||
|
||
var stand = await client.GetFromJsonAsync<ScanStatus>($"/api/v1/libraries/{bibliothek}/scan");
|
||
Assert.That(stand!.State, Is.EqualTo("idle"));
|
||
}
|
||
|
||
[Test]
|
||
public async Task Ein_gewoehnlicher_Benutzer_stoesst_keinen_Scan_an()
|
||
{
|
||
using var server = new FlaroServer();
|
||
var (admin, bibliothek) = await MitBibliothek(server, "Movies");
|
||
await admin.PostAsJsonAsync("/api/v1/users",
|
||
new CreateUserRequest("gast", "auch-ein-langes-passwort", false));
|
||
var gast = await server.SignIn("gast", "auch-ein-langes-passwort", "iPad", "g-9");
|
||
|
||
var versuch = await server.AlsAngemeldeter(gast.Token)
|
||
.PostAsync($"/api/v1/libraries/{bibliothek}/scan", null);
|
||
|
||
Assert.That(versuch.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
|
||
}
|
||
|
||
[Test]
|
||
public async Task Eine_Bibliothek_die_es_nicht_gibt_laesst_sich_nicht_scannen()
|
||
{
|
||
using var server = new FlaroServer();
|
||
var (client, _) = await MitBibliothek(server, "Movies");
|
||
|
||
var versuch = await client.PostAsync($"/api/v1/libraries/{Guid.CreateVersion7()}/scan", null);
|
||
Assert.That(versuch.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
|
||
}
|
||
}
|