247 lines
9.0 KiB
C#
247 lines
9.0 KiB
C#
using System.Text.Json;
|
|
using PLib.Infrastructure.Metadata;
|
|
using Shouldly;
|
|
|
|
namespace PLib.Tests.Metadata;
|
|
|
|
/// <summary>
|
|
/// Decoding a stash-box reply, against payloads shaped like the real ones.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This is the part of the feature that cannot be checked without a server and a key, and the
|
|
/// part where a wrong guess looks exactly like "the source knows nothing about your video".
|
|
/// </remarks>
|
|
public sealed class StashBoxPayloadTests
|
|
{
|
|
/// <summary>The newer query, whose result is one group of scenes per group of fingerprints.</summary>
|
|
private static StashBoxMetadataProvider.GraphQlQuery Nested => StashBoxMetadataProvider.Queries[0];
|
|
|
|
/// <summary>The older query, kept for instances that have not been updated.</summary>
|
|
private static StashBoxMetadataProvider.GraphQlQuery Flat => StashBoxMetadataProvider.Queries[1];
|
|
|
|
[Fact]
|
|
public void The_newer_query_returns_scenes_one_level_deeper_and_they_are_flattened()
|
|
{
|
|
const string payload = """
|
|
{
|
|
"data": {
|
|
"findScenesBySceneFingerprints": [
|
|
[
|
|
{
|
|
"id": "abc",
|
|
"title": "Первая",
|
|
"details": "Описание",
|
|
"studio": { "name": "Студия" },
|
|
"tags": [ { "name": "драма" }, { "name": "нуар" } ],
|
|
"performers": [ { "performer": { "name": "Актёр" }, "as": "Псевдоним" } ]
|
|
},
|
|
{ "id": "def", "title": "Вторая", "studio": null, "tags": [], "performers": [] }
|
|
]
|
|
]
|
|
}
|
|
}
|
|
""";
|
|
|
|
var matches = Read(payload, Nested);
|
|
|
|
matches.Count.ShouldBe(2);
|
|
|
|
var first = matches[0];
|
|
first.SourceName.ShouldBe("StashDB");
|
|
first.RemoteId.ShouldBe("abc");
|
|
first.Title.ShouldBe("Первая");
|
|
first.Description.ShouldBe("Описание");
|
|
first.Studios.Select(x => x.Name).ShouldBe(["Студия"]);
|
|
first.Tags.Select(x => x.Name).ShouldBe(["драма", "нуар"]);
|
|
|
|
// The credited alias is not the person; the label has to be the performer's own name.
|
|
first.Performers.Select(x => x.Name).ShouldBe(["Актёр"]);
|
|
|
|
matches[1].Studios.ShouldBeEmpty();
|
|
}
|
|
|
|
[Fact]
|
|
public void The_older_query_returns_a_flat_list()
|
|
{
|
|
const string payload = """
|
|
{
|
|
"data": {
|
|
"findSceneByFingerprint": [
|
|
{ "id": "abc", "title": "Сцена", "studio": { "name": "Студия" }, "tags": [], "performers": [] }
|
|
]
|
|
}
|
|
}
|
|
""";
|
|
|
|
Read(payload, Flat).ShouldHaveSingleItem().Title.ShouldBe("Сцена");
|
|
}
|
|
|
|
[Fact]
|
|
public void A_reply_with_no_matches_is_an_empty_list_rather_than_a_failure()
|
|
{
|
|
Read("""{ "data": { "findScenesBySceneFingerprints": [ [] ] } }""", Nested).ShouldBeEmpty();
|
|
Read("""{ "data": { "findScenesBySceneFingerprints": null } }""", Nested).ShouldBeEmpty();
|
|
}
|
|
|
|
[Fact]
|
|
public void A_scene_without_a_title_still_produces_a_match_that_can_be_shown()
|
|
{
|
|
var match = Read(
|
|
"""{ "data": { "findSceneByFingerprint": [ { "id": "abc", "title": null } ] } }""",
|
|
Flat).ShouldHaveSingleItem();
|
|
|
|
match.Title.ShouldNotBeNullOrWhiteSpace();
|
|
match.Tags.ShouldBeEmpty();
|
|
}
|
|
|
|
[Fact]
|
|
public void The_smallest_picture_still_wide_enough_for_a_card_is_the_one_kept()
|
|
{
|
|
// stash-box returns every size it holds, and the first is not the best: originals run
|
|
// to several thousand pixels, and one of those per performer to draw it 150 wide would
|
|
// cost megabytes a head.
|
|
const string payload = """
|
|
{
|
|
"data": {
|
|
"findSceneByFingerprint": [
|
|
{
|
|
"id": "abc",
|
|
"title": "Сцена",
|
|
"studio": { "name": "Студия", "images": [ { "url": "s/4000.jpg", "width": 4000 }, { "url": "s/500.jpg", "width": 500 } ] },
|
|
"tags": [ { "name": "драма" } ],
|
|
"performers": [
|
|
{ "performer": { "name": "Актёр", "images": [
|
|
{ "url": "p/2000.jpg", "width": 2000 },
|
|
{ "url": "p/400.jpg", "width": 400 },
|
|
{ "url": "p/100.jpg", "width": 100 } ] } }
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
""";
|
|
|
|
var match = Read(payload, Flat).ShouldHaveSingleItem();
|
|
|
|
match.Performers.Single().ImageUrl.ShouldBe("p/400.jpg");
|
|
match.Studios.Single().ImageUrl.ShouldBe("s/500.jpg");
|
|
|
|
// stash-box holds no picture for a tag at all, so there is nothing to find.
|
|
match.Tags.Single().ImageUrl.ShouldBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public void The_scene_carries_its_own_cover_apart_from_the_pictures_of_its_people()
|
|
{
|
|
const string payload = """
|
|
{
|
|
"data": {
|
|
"findSceneByFingerprint": [
|
|
{
|
|
"id": "abc",
|
|
"title": "Сцена",
|
|
"images": [ { "url": "scene/1920.jpg", "width": 1920 }, { "url": "scene/640.jpg", "width": 640 } ],
|
|
"performers": [ { "performer": { "name": "Актёр", "images": [ { "url": "p/400.jpg", "width": 400 } ] } } ]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
""";
|
|
|
|
var match = Read(payload, Flat).ShouldHaveSingleItem();
|
|
|
|
match.ImageUrl.ShouldBe("scene/640.jpg");
|
|
match.Performers.Single().ImageUrl.ShouldBe("p/400.jpg");
|
|
|
|
// Still a URL, and it stays one: whether to spend the bandwidth is the caller's
|
|
// decision, and a candidate must never wait on a picture host to be shown.
|
|
match.ImageUrl.ShouldNotBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public void When_every_picture_is_too_small_the_widest_is_taken_rather_than_none()
|
|
{
|
|
const string payload = """
|
|
{
|
|
"data": {
|
|
"findSceneByFingerprint": [
|
|
{
|
|
"id": "abc",
|
|
"title": "Сцена",
|
|
"performers": [
|
|
{ "performer": { "name": "Актёр", "images": [
|
|
{ "url": "p/80.jpg", "width": 80 },
|
|
{ "url": "p/200.jpg", "width": 200 } ] } }
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
""";
|
|
|
|
// A small picture beats an empty card.
|
|
Read(payload, Flat).Single().Performers.Single().ImageUrl.ShouldBe("p/200.jpg");
|
|
}
|
|
|
|
[Fact]
|
|
public void An_entity_with_no_pictures_at_all_is_still_a_match()
|
|
{
|
|
const string payload = """
|
|
{
|
|
"data": {
|
|
"findSceneByFingerprint": [
|
|
{
|
|
"id": "abc",
|
|
"title": "Сцена",
|
|
"studio": { "name": "Студия", "images": [] },
|
|
"performers": [ { "performer": { "name": "Актёр" } } ]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
""";
|
|
|
|
var match = Read(payload, Flat).ShouldHaveSingleItem();
|
|
|
|
match.Studios.Single().ImageUrl.ShouldBeNull();
|
|
match.Performers.Single().Name.ShouldBe("Актёр");
|
|
}
|
|
|
|
[Fact]
|
|
public void Errors_are_raised_even_though_the_server_answered_two_hundred()
|
|
{
|
|
// A rejected key comes back as 200 with an errors array; treating that as "nothing
|
|
// found" would tell the user their video is unknown rather than their key is wrong.
|
|
var payload = """{ "errors": [ { "message": "unauthorized" } ], "data": null }""";
|
|
|
|
Should.Throw<InvalidOperationException>(() => Read(payload, Nested))
|
|
.Message.ShouldBe("unauthorized");
|
|
}
|
|
|
|
[Fact]
|
|
public void A_missing_field_is_reported_apart_from_other_errors_so_the_older_query_gets_a_turn()
|
|
{
|
|
// Verbatim from a live instance that only has the newer query.
|
|
var payload = """
|
|
{
|
|
"errors": [
|
|
{ "message": "Cannot query field \"findSceneByFingerprint\" on type \"Query\". Did you mean \"findScenesBySceneFingerprints\"?" }
|
|
]
|
|
}
|
|
""";
|
|
|
|
var rejected = Should.Throw<Exception>(() => Read(payload, Flat));
|
|
|
|
// Not the type the caller reports as a failure: this one means "try the next query".
|
|
rejected.ShouldNotBeOfType<InvalidOperationException>();
|
|
}
|
|
|
|
private static IReadOnlyList<PLib.Application.Metadata.VideoMetadataMatch> Read(
|
|
string payload,
|
|
StashBoxMetadataProvider.GraphQlQuery query)
|
|
{
|
|
using var document = JsonDocument.Parse(payload);
|
|
return StashBoxMetadataProvider.ReadPayload(document.RootElement, query, "StashDB");
|
|
}
|
|
}
|