Desk: the fork desk's Bifrost half (#40)
This commit is contained in:
parent
12a153f66f
commit
7e9ba5796b
28 changed files with 20775 additions and 6 deletions
68
src/Bifrost.Web/Configuration/DeskOptions.cs
Normal file
68
src/Bifrost.Web/Configuration/DeskOptions.cs
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
namespace Bifrost.Web.Configuration;
|
||||
|
||||
// The fork desk's configuration (CultLib fork-card.md, Transport; M1 and M5). Minds is an ARRAY, never a map keyed
|
||||
// by Mind id: configuration keys are case-insensitive, so a keyed section would let GAMECULT-CHAT reach
|
||||
// gamecult-chat. Account ids are lowercase D-format Guids. An empty Minds list means the desk is not configured.
|
||||
public sealed class DeskOptions
|
||||
{
|
||||
public const string SectionName = "Desk";
|
||||
|
||||
public List<DeskMindOptions> Minds { get; init; } = [];
|
||||
|
||||
public DeskAttributionOptions Attribution { get; init; } = new();
|
||||
|
||||
// The one origin allowed to call /api/desk from a browser (exactly this, no credentials).
|
||||
public string AllowedOrigin { get; init; } = string.Empty;
|
||||
|
||||
// The cap on an answer body, in bytes, judged before it is parsed.
|
||||
public int MaxBodyBytes { get; init; } = 16 * 1024;
|
||||
|
||||
// What an `unavailable` document tells the client to wait.
|
||||
public int RetryAfterSeconds { get; init; } = 30;
|
||||
|
||||
public bool IsConfigured => Minds.Count > 0;
|
||||
}
|
||||
|
||||
public sealed class DeskMindOptions
|
||||
{
|
||||
public string Id { get; init; } = string.Empty;
|
||||
|
||||
// The full path of this Mind's socket on the peer-checked door. Bifrost only connects to it.
|
||||
public string Socket { get; init; } = string.Empty;
|
||||
|
||||
// Accounts that may answer this Mind's forks. Sent to Huginn with every call; no request sets or extends it.
|
||||
public List<string> Deciders { get; init; } = [];
|
||||
|
||||
// Huginn's bound on the list a call carries (fork-card.md: one to 64 ids).
|
||||
public const int MaxDeciders = 64;
|
||||
|
||||
// One to 64 ids, none repeated. The startup validator and the request path both ask this one question.
|
||||
public static bool DecidersWithinBounds(IReadOnlyCollection<string> deciders) =>
|
||||
deciders.Count is >= 1 and <= MaxDeciders && deciders.Distinct(StringComparer.Ordinal).Count() == deciders.Count;
|
||||
}
|
||||
|
||||
// The authority a stamped answer carries (fork-card.md: Operator, Steward or Member), from configuration because
|
||||
// Bifrost has no such roles: Operator is one account, Stewards a list, everyone else a Member.
|
||||
public sealed class DeskAttributionOptions
|
||||
{
|
||||
public string? Operator { get; init; }
|
||||
|
||||
public List<string> Stewards { get; init; } = [];
|
||||
|
||||
public string AuthorityOf(string accountId)
|
||||
{
|
||||
if (!string.IsNullOrEmpty(Operator) && string.Equals(accountId, Operator, StringComparison.Ordinal))
|
||||
{
|
||||
return DeskAuthority.Operator;
|
||||
}
|
||||
|
||||
return Stewards.Contains(accountId, StringComparer.Ordinal) ? DeskAuthority.Steward : DeskAuthority.Member;
|
||||
}
|
||||
}
|
||||
|
||||
public static class DeskAuthority
|
||||
{
|
||||
public const string Operator = "Operator";
|
||||
public const string Steward = "Steward";
|
||||
public const string Member = "Member";
|
||||
}
|
||||
270
src/Bifrost.Web/Features/Desk/DeskBodyShape.cs
Normal file
270
src/Bifrost.Web/Features/Desk/DeskBodyShape.cs
Normal file
|
|
@ -0,0 +1,270 @@
|
|||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using System.Text.RegularExpressions;
|
||||
|
||||
namespace Bifrost.Web.Features.Desk;
|
||||
|
||||
// The edge's judgment of an answer body (fork-card.md, answer_request, steps 1 and 2). It checks the shape only:
|
||||
// whether the answer is legal (a retraction's target, the choice, the fork) is Huginn's. A body that passes is
|
||||
// forwarded as the bytes received; the parsed request is returned for the door's context and for tests.
|
||||
public sealed record DeskBodyVerdict(AnswerRequest? Request, string? RefusalCode)
|
||||
{
|
||||
public static DeskBodyVerdict Pass(AnswerRequest request) => new(request, null);
|
||||
|
||||
public static DeskBodyVerdict Refuse(string code) => new(null, code);
|
||||
}
|
||||
|
||||
public static partial class DeskBodyShape
|
||||
{
|
||||
public const int MaxNoteBytes = 4000;
|
||||
|
||||
// Two keys the receiver alone stamps. Refused whole at any depth, never stripped.
|
||||
private static readonly string[] ForbiddenKeys = ["answerer", "authority"];
|
||||
|
||||
private static readonly string[] TopKeys =
|
||||
["schemaVersion", "fork_id", "options_hash", "answer", "retracted", "retracts", "answered_at", "request_id"];
|
||||
|
||||
private static readonly string[] AnswerKeys = ["choice", "note"];
|
||||
|
||||
private static readonly UTF8Encoding StrictUtf8 = new(false, true);
|
||||
|
||||
private static readonly JsonDocumentOptions ParseOptions = new() { MaxDepth = 32 };
|
||||
|
||||
public static DeskBodyVerdict Judge(ReadOnlySpan<byte> body, int maxBodyBytes)
|
||||
{
|
||||
if (body.Length > maxBodyBytes)
|
||||
{
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyInvalid);
|
||||
}
|
||||
|
||||
JsonDocument document;
|
||||
try
|
||||
{
|
||||
document = JsonDocument.Parse(body.ToArray(), ParseOptions);
|
||||
}
|
||||
catch (JsonException)
|
||||
{
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyInvalid);
|
||||
}
|
||||
|
||||
using (document)
|
||||
{
|
||||
try
|
||||
{
|
||||
return JudgeParsed(document.RootElement);
|
||||
}
|
||||
catch (InvalidOperationException)
|
||||
{
|
||||
// A string the parser accepted but cannot decode: invalid UTF-8 or a lone surrogate.
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyInvalid);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static DeskBodyVerdict JudgeParsed(JsonElement root)
|
||||
{
|
||||
if (HasForbiddenKey(root))
|
||||
{
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyForbiddenField);
|
||||
}
|
||||
|
||||
if (root.ValueKind != JsonValueKind.Object)
|
||||
{
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyInvalid);
|
||||
}
|
||||
|
||||
var top = Members(root);
|
||||
if (top is null)
|
||||
{
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyInvalid);
|
||||
}
|
||||
|
||||
// Unknown keys, including inside the answer object, before any value is judged.
|
||||
if (top.Keys.Any(key => !TopKeys.Contains(key, StringComparer.Ordinal)))
|
||||
{
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyUnknownField);
|
||||
}
|
||||
|
||||
Dictionary<string, JsonElement>? answerMembers = null;
|
||||
if (top.TryGetValue("answer", out var answerElement) && answerElement.ValueKind == JsonValueKind.Object)
|
||||
{
|
||||
answerMembers = Members(answerElement);
|
||||
if (answerMembers is not null &&
|
||||
answerMembers.Keys.Any(key => !AnswerKeys.Contains(key, StringComparer.Ordinal)))
|
||||
{
|
||||
return DeskBodyVerdict.Refuse(DeskRefusals.BodyUnknownField);
|
||||
}
|
||||
}
|
||||
|
||||
return Shape(top, answerMembers);
|
||||
}
|
||||
|
||||
private static DeskBodyVerdict Shape(Dictionary<string, JsonElement> top, Dictionary<string, JsonElement>? answerMembers)
|
||||
{
|
||||
var invalid = DeskBodyVerdict.Refuse(DeskRefusals.BodyInvalid);
|
||||
|
||||
// Map-mode: every key is written.
|
||||
if (TopKeys.Any(key => !top.ContainsKey(key)))
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
if (!IsString(top["schemaVersion"], out var schemaVersion) || schemaVersion != DeskSchemas.AnswerRequest ||
|
||||
!IsString(top["fork_id"], out var forkId) || forkId.Length == 0 ||
|
||||
!IsString(top["options_hash"], out var optionsHash) || !Hex64().IsMatch(optionsHash) ||
|
||||
!IsString(top["answered_at"], out var answeredAt) || !Instant().IsMatch(answeredAt) ||
|
||||
!IsString(top["request_id"], out var requestId) || !RequestId().IsMatch(requestId))
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
var retractedElement = top["retracted"];
|
||||
if (retractedElement.ValueKind is not (JsonValueKind.True or JsonValueKind.False))
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
var retracted = retractedElement.ValueKind == JsonValueKind.True;
|
||||
|
||||
string? retracts = null;
|
||||
if (top["retracts"].ValueKind != JsonValueKind.Null)
|
||||
{
|
||||
if (!IsString(top["retracts"], out var target) || !AnswerId().IsMatch(target))
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
retracts = target;
|
||||
}
|
||||
|
||||
AnswerObject? answer = null;
|
||||
if (top["answer"].ValueKind != JsonValueKind.Null)
|
||||
{
|
||||
if (answerMembers is null || AnswerKeys.Any(key => !answerMembers.ContainsKey(key)))
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
string? choice = null;
|
||||
if (answerMembers["choice"].ValueKind != JsonValueKind.Null)
|
||||
{
|
||||
if (!IsString(answerMembers["choice"], out var picked) || picked.Length == 0)
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
choice = picked;
|
||||
}
|
||||
|
||||
string? note = null;
|
||||
if (answerMembers["note"].ValueKind != JsonValueKind.Null)
|
||||
{
|
||||
if (!IsString(answerMembers["note"], out var words) || !IsWords(words))
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
note = words;
|
||||
}
|
||||
|
||||
if (choice is null && note is null)
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
answer = new AnswerObject(choice, note);
|
||||
}
|
||||
|
||||
// No answer and no retraction is no request. The illegal retraction forms (a target-less retraction, a
|
||||
// retraction carrying an answer, a target on a plain answer) pass here: Huginn stores them as bad_retraction.
|
||||
if (answer is null && !retracted)
|
||||
{
|
||||
return invalid;
|
||||
}
|
||||
|
||||
return DeskBodyVerdict.Pass(new AnswerRequest(
|
||||
schemaVersion, forkId, optionsHash, answer, retracted, retracts, answeredAt, requestId));
|
||||
}
|
||||
|
||||
// A note is 1 to 4000 UTF-8 bytes and not whitespace only. Bytes, not characters or UTF-16 units.
|
||||
private static bool IsWords(string value)
|
||||
{
|
||||
int bytes;
|
||||
try
|
||||
{
|
||||
bytes = StrictUtf8.GetByteCount(value);
|
||||
}
|
||||
catch (EncoderFallbackException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return bytes is >= 1 and <= MaxNoteBytes && !value.All(IsSchemaSpace);
|
||||
}
|
||||
|
||||
// The whitespace set of the schema's `words` pattern.
|
||||
private static bool IsSchemaSpace(char c) =>
|
||||
c is (>= (char)0x09 and <= (char)0x0d) or (char)0x20 or (char)0x85 or (char)0xa0 or (char)0x1680
|
||||
or (>= (char)0x2000 and <= (char)0x200a) or (char)0x2028 or (char)0x2029 or (char)0x202f or (char)0x205f or (char)0x3000;
|
||||
|
||||
private static bool IsString(JsonElement element, out string value)
|
||||
{
|
||||
value = string.Empty;
|
||||
if (element.ValueKind != JsonValueKind.String)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
value = element.GetString() ?? string.Empty;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Object members by unescaped name; null when a name repeats, because the forwarded bytes would then mean
|
||||
// different things to different parsers.
|
||||
private static Dictionary<string, JsonElement>? Members(JsonElement element)
|
||||
{
|
||||
var members = new Dictionary<string, JsonElement>(StringComparer.Ordinal);
|
||||
foreach (var property in element.EnumerateObject())
|
||||
{
|
||||
if (!members.TryAdd(property.Name, property.Value))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
return members;
|
||||
}
|
||||
|
||||
private static bool HasForbiddenKey(JsonElement element)
|
||||
{
|
||||
switch (element.ValueKind)
|
||||
{
|
||||
case JsonValueKind.Object:
|
||||
foreach (var property in element.EnumerateObject())
|
||||
{
|
||||
if (ForbiddenKeys.Contains(property.Name, StringComparer.Ordinal) || HasForbiddenKey(property.Value))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
case JsonValueKind.Array:
|
||||
return element.EnumerateArray().Any(HasForbiddenKey);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
[GeneratedRegex(@"^[0-9a-f]{64}\z")]
|
||||
private static partial Regex Hex64();
|
||||
|
||||
[GeneratedRegex(@"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]{1,7})?Z\z")]
|
||||
private static partial Regex Instant();
|
||||
|
||||
[GeneratedRegex(@"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z")]
|
||||
private static partial Regex RequestId();
|
||||
|
||||
[GeneratedRegex(@"^n[1-9][0-9]*\z")]
|
||||
private static partial Regex AnswerId();
|
||||
}
|
||||
194
src/Bifrost.Web/Features/Desk/DeskDocuments.cs
Normal file
194
src/Bifrost.Web/Features/Desk/DeskDocuments.cs
Normal file
|
|
@ -0,0 +1,194 @@
|
|||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
|
||||
namespace Bifrost.Web.Features.Desk;
|
||||
|
||||
// The fork-desk documents Bifrost reads or writes, spelled as CultLib's contracts/cultnet/governance/fork-card.md
|
||||
// (commit 89755b08) spells them: snake_case keys, every key written (nil where absent), declared in the
|
||||
// contract's key order. Bifrost authors only DeskRefusal and DeskUnavailable. AnswerRequest is the client's body;
|
||||
// ForkCard, DeskAnswerDocument and AnswerResult are Huginn's documents, typed here so they pass through unchanged.
|
||||
|
||||
public static class DeskSchemas
|
||||
{
|
||||
public const string AnswerRequest = "gamecult.fork.answer_request.v0";
|
||||
public const string AnswerResult = "gamecult.fork.answer_result.v0";
|
||||
public const string Card = "gamecult.fork.card.v0";
|
||||
public const string DeskAnswer = "gamecult.desk_answer.v0";
|
||||
public const string Refusal = "gamecult.fork.refusal.v0";
|
||||
public const string Unavailable = "gamecult.fork.unavailable.v0";
|
||||
}
|
||||
|
||||
public static class DeskJson
|
||||
{
|
||||
// Defaults write nulls, which map-mode needs ("every key written").
|
||||
public static readonly JsonSerializerOptions Options = new()
|
||||
{
|
||||
// The documents are not HTML: keep apostrophes and non-ASCII text as written.
|
||||
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
|
||||
};
|
||||
}
|
||||
|
||||
public sealed record AnswerObject(
|
||||
[property: JsonPropertyName("choice")] string? Choice,
|
||||
[property: JsonPropertyName("note")] string? Note);
|
||||
|
||||
public sealed record AnswerRequest(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("fork_id")] string ForkId,
|
||||
[property: JsonPropertyName("options_hash")] string OptionsHash,
|
||||
[property: JsonPropertyName("answer")] AnswerObject? Answer,
|
||||
[property: JsonPropertyName("retracted")] bool Retracted,
|
||||
[property: JsonPropertyName("retracts")] string? Retracts,
|
||||
[property: JsonPropertyName("answered_at")] string AnsweredAt,
|
||||
[property: JsonPropertyName("request_id")] string RequestId);
|
||||
|
||||
public sealed record DeskRefusal(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("code")] string Code,
|
||||
[property: JsonPropertyName("error")] string Error);
|
||||
|
||||
public sealed record DeskUnavailable(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("code")] string Code,
|
||||
[property: JsonPropertyName("error")] string Error,
|
||||
[property: JsonPropertyName("retryAfterSeconds")] int? RetryAfterSeconds);
|
||||
|
||||
public sealed record ForkOption(
|
||||
[property: JsonPropertyName("id")] string Id,
|
||||
[property: JsonPropertyName("text")] string Text);
|
||||
|
||||
public sealed record ForkRef(
|
||||
[property: JsonPropertyName("kind")] string Kind,
|
||||
[property: JsonPropertyName("id")] string Id);
|
||||
|
||||
public sealed record ForkCard(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("fork_id")] string ForkId,
|
||||
[property: JsonPropertyName("title")] string Title,
|
||||
[property: JsonPropertyName("context")] string Context,
|
||||
[property: JsonPropertyName("options")] ForkOption[] Options,
|
||||
[property: JsonPropertyName("recommendation")] string Recommendation,
|
||||
[property: JsonPropertyName("depends")] string[] Depends,
|
||||
[property: JsonPropertyName("leans")] string? Leans,
|
||||
[property: JsonPropertyName("flag")] string? Flag,
|
||||
[property: JsonPropertyName("raised_in")] ForkRef? RaisedIn,
|
||||
[property: JsonPropertyName("deciders")] string[] Deciders,
|
||||
[property: JsonPropertyName("status")] string Status,
|
||||
[property: JsonPropertyName("ruling")] string? Ruling,
|
||||
[property: JsonPropertyName("ruled_from")] string[] RuledFrom,
|
||||
[property: JsonPropertyName("order")] long Order,
|
||||
[property: JsonPropertyName("options_hash")] string OptionsHash);
|
||||
|
||||
// One stored answer: Counted, Revision, Retraction or Refused, told apart by Outcome and Code.
|
||||
public sealed record DeskAnswerDocument(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("answer_id")] string AnswerId,
|
||||
[property: JsonPropertyName("fork_id")] string ForkId,
|
||||
[property: JsonPropertyName("outcome")] string Outcome,
|
||||
[property: JsonPropertyName("of")] string? Of,
|
||||
[property: JsonPropertyName("retracts")] string? Retracts,
|
||||
[property: JsonPropertyName("code")] string? Code,
|
||||
[property: JsonPropertyName("options_hash")] string OptionsHash,
|
||||
[property: JsonPropertyName("choice")] string? Choice,
|
||||
[property: JsonPropertyName("note")] string? Note,
|
||||
[property: JsonPropertyName("answered_at")] string AnsweredAt,
|
||||
[property: JsonPropertyName("received_at")] string ReceivedAt,
|
||||
[property: JsonPropertyName("claim_in_future")] bool ClaimInFuture,
|
||||
[property: JsonPropertyName("answerer")] string Answerer,
|
||||
[property: JsonPropertyName("authority")] string Authority,
|
||||
[property: JsonPropertyName("request_id")] string RequestId);
|
||||
|
||||
public sealed record ForkRecord(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("fork_id")] string ForkId,
|
||||
[property: JsonPropertyName("options_hash")] string OptionsHash,
|
||||
[property: JsonPropertyName("counted_answer_id")] string? CountedAnswerId,
|
||||
[property: JsonPropertyName("answers")] DeskAnswerDocument[] Answers);
|
||||
|
||||
public sealed record ForkEntry(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("card")] ForkCard Card,
|
||||
[property: JsonPropertyName("record")] ForkRecord Record);
|
||||
|
||||
public sealed record ForkList(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("mind")] string Mind,
|
||||
[property: JsonPropertyName("stamp")] string Stamp,
|
||||
[property: JsonPropertyName("open_count")] int OpenCount,
|
||||
[property: JsonPropertyName("recorded_count")] int RecordedCount,
|
||||
[property: JsonPropertyName("forks")] ForkEntry[] Forks,
|
||||
[property: JsonPropertyName("next_cursor")] string? NextCursor);
|
||||
|
||||
public sealed record AnswerResult(
|
||||
[property: JsonPropertyName("schemaVersion")] string SchemaVersion,
|
||||
[property: JsonPropertyName("answer")] DeskAnswerDocument Answer,
|
||||
[property: JsonPropertyName("card")] ForkCard? Card,
|
||||
[property: JsonPropertyName("counted_answer_id")] string? CountedAnswerId);
|
||||
|
||||
// The refusal codes Bifrost itself writes, each with its one status and message (vectors doorRefusals).
|
||||
public static class DeskRefusals
|
||||
{
|
||||
public const string Unauthenticated = "unauthenticated";
|
||||
public const string BodyForbiddenField = "body_forbidden_field";
|
||||
public const string BodyUnknownField = "body_unknown_field";
|
||||
public const string BodyInvalid = "body_invalid";
|
||||
public const string ForkUnknown = "fork_unknown";
|
||||
public const string InsufficientScope = "insufficient_scope";
|
||||
public const string Forbidden = "forbidden";
|
||||
public const string RequestInvalid = "request_invalid";
|
||||
public const string RequestIdConflict = "request_id_conflict";
|
||||
|
||||
private static readonly Dictionary<string, (int Status, string Error)> Table = new(StringComparer.Ordinal)
|
||||
{
|
||||
[Unauthenticated] = (401, "unauthenticated: a verified session is required"),
|
||||
[BodyForbiddenField] = (400, "body_forbidden_field: answerer and authority are set by the receiver"),
|
||||
[BodyUnknownField] = (400, "body_unknown_field: the body is a closed shape"),
|
||||
[BodyInvalid] = (400, "body_invalid: the body does not satisfy gamecult.fork.answer_request.v0"),
|
||||
[ForkUnknown] = (404, "fork_unknown: no such fork"),
|
||||
[InsufficientScope] = (403, "insufficient_scope: the token lacks the scope this route needs"),
|
||||
[Forbidden] = (403, "forbidden: only Active members may use the desk"),
|
||||
[RequestInvalid] = (400, "request_invalid: the request does not satisfy its document"),
|
||||
[RequestIdConflict] = (409, "request_id_conflict: this request_id was used for a different body"),
|
||||
};
|
||||
|
||||
// fork_too_large (Libby's ruling) is list-only and names its fork, so it is built here, not read from the table.
|
||||
// Not a literal const: the pinned vectors' doorRefusals do not name it yet, and the schema test pins literals to them.
|
||||
public static string ForkTooLarge => "fork_too_large";
|
||||
|
||||
public static int ForkTooLargeStatus => 422;
|
||||
|
||||
public static DeskRefusal ForkTooLargeDocument(string forkId, int order) => new(
|
||||
DeskSchemas.Refusal,
|
||||
ForkTooLarge,
|
||||
order > 0
|
||||
? $"fork_too_large: fork {forkId} (order {order}) is too large for a page; continue with cursor c{order}"
|
||||
: $"fork_too_large: fork {forkId} (order {order}) is too large for a page; the list has reached its end");
|
||||
|
||||
public static bool IsKnown(string code) => Table.ContainsKey(code);
|
||||
|
||||
public static int StatusOf(string code) => Table[code].Status;
|
||||
|
||||
public static DeskRefusal Document(string code) => new(DeskSchemas.Refusal, code, Table[code].Error);
|
||||
}
|
||||
|
||||
public static class DeskUnavailables
|
||||
{
|
||||
public const int Status = 503;
|
||||
|
||||
public static DeskUnavailable Document(int? retryAfterSeconds) => new(
|
||||
DeskSchemas.Unavailable,
|
||||
"unavailable",
|
||||
"unavailable: the outcome is not confirmed, try again with the same request_id",
|
||||
retryAfterSeconds);
|
||||
}
|
||||
|
||||
// Notes are returned only to deciders. For everyone else Bifrost nils every note at the door: the key stays written
|
||||
// (every key written, nil where absent), so the stripped body is still the contract's shape. Cards, outcomes, codes
|
||||
// and counts are untouched; Huginn returns the full record.
|
||||
public static class DeskNotes
|
||||
{
|
||||
public static ForkEntry Strip(ForkEntry entry) =>
|
||||
entry with { Record = entry.Record with { Answers = [.. entry.Record.Answers.Select(a => a with { Note = null })] } };
|
||||
|
||||
public static ForkList Strip(ForkList list) => list with { Forks = [.. list.Forks.Select(Strip)] };
|
||||
}
|
||||
445
src/Bifrost.Web/Features/Desk/DeskEndpoints.cs
Normal file
445
src/Bifrost.Web/Features/Desk/DeskEndpoints.cs
Normal file
|
|
@ -0,0 +1,445 @@
|
|||
using System.Text.Json;
|
||||
using Bifrost.Web.Configuration;
|
||||
using Bifrost.Web.Data;
|
||||
using Bifrost.Web.Features.Oidc;
|
||||
using Microsoft.AspNetCore.Cors.Infrastructure;
|
||||
using Microsoft.AspNetCore.Routing;
|
||||
using Microsoft.Extensions.Options;
|
||||
using Microsoft.Net.Http.Headers;
|
||||
|
||||
namespace Bifrost.Web.Features.Desk;
|
||||
|
||||
// The fork desk's HTTP edge (fork-card.md, Transport). One catch-all under /api/desk judges, in this order and no
|
||||
// other: the raw target, the bearer, its audience, its scope, Active membership (the body is unread), the body's
|
||||
// shape, the {mind} lookup, the door. Every refusal is a contract document. Bifrost holds no fork state: it passes
|
||||
// Huginn's outcome through, attaches the current card to a stale_fork answer, and says `unavailable` when the door
|
||||
// cannot confirm an outcome.
|
||||
public static class DeskEndpoints
|
||||
{
|
||||
public const string RoutePrefix = "/api/desk";
|
||||
public const string Audience = "bifrost-desk";
|
||||
public const string ReadScope = "desk.read";
|
||||
public const string AnswerScope = "desk.answer";
|
||||
public const string CorsPolicy = "DeskCors";
|
||||
|
||||
public static IServiceCollection AddBifrostDesk(this IServiceCollection services)
|
||||
{
|
||||
services.AddSingleton(provider => new DeskMindRoutes(provider.GetRequiredService<IOptions<DeskOptions>>().Value.Minds));
|
||||
services.AddCors();
|
||||
// Exactly the configured origin, no credentials, and only on the routes that require this policy.
|
||||
services
|
||||
.AddOptions<CorsOptions>()
|
||||
.Configure<IOptions<DeskOptions>>((cors, desk) =>
|
||||
cors.AddPolicy(
|
||||
CorsPolicy,
|
||||
policy => policy
|
||||
.WithOrigins(desk.Value.AllowedOrigin)
|
||||
.WithMethods("GET", "POST")
|
||||
.WithHeaders(HeaderNames.Authorization, HeaderNames.ContentType)));
|
||||
return services;
|
||||
}
|
||||
|
||||
public static IEndpointConventionBuilder MapDesk(this IEndpointRouteBuilder app)
|
||||
{
|
||||
// A configured desk with no credential or door port would serve nothing true: stop startup instead.
|
||||
app.ServiceProvider.GetRequiredService<IDeskCredential>();
|
||||
app.ServiceProvider.GetRequiredService<IDeskDoor>();
|
||||
|
||||
return app.MapMethods(RoutePrefix + "/{**rest}", ["GET", "POST"], HandleAsync)
|
||||
.RequireCors(CorsPolicy)
|
||||
.AllowAnonymous();
|
||||
}
|
||||
|
||||
private static async Task HandleAsync(
|
||||
HttpContext http,
|
||||
IDeskCredential credential,
|
||||
IDeskDoor door,
|
||||
DeskMindRoutes minds,
|
||||
IOptions<DeskOptions> options,
|
||||
BifrostDbContext db)
|
||||
{
|
||||
var cancellationToken = http.RequestAborted;
|
||||
var desk = options.Value;
|
||||
http.Response.Headers.Append(HeaderNames.Vary, "Origin");
|
||||
http.Response.Headers.CacheControl = "no-store";
|
||||
|
||||
// 1. The raw target, never the decoded Request.Path.
|
||||
var rawTarget = http.Features.Get<Microsoft.AspNetCore.Http.Features.IHttpRequestFeature>()?.RawTarget ?? string.Empty;
|
||||
var route = DeskRoute.Parse(http.Request.Method, rawTarget);
|
||||
if (route is null)
|
||||
{
|
||||
await WriteRefusalAsync(http, DeskRefusals.ForkUnknown);
|
||||
return;
|
||||
}
|
||||
|
||||
// 2-4. Bearer, audience, scope.
|
||||
DeskToken? token;
|
||||
try
|
||||
{
|
||||
token = await credential.AuthenticateAsync(http, cancellationToken);
|
||||
}
|
||||
catch (Exception) when (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
// The bearer could not be judged: neither a pass nor a refusal of the caller.
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
return;
|
||||
}
|
||||
|
||||
if (token is null || !string.Equals(token.Audience, Audience, StringComparison.Ordinal))
|
||||
{
|
||||
await WriteRefusalAsync(http, DeskRefusals.Unauthenticated);
|
||||
return;
|
||||
}
|
||||
|
||||
var scope = route.Kind == DeskRouteKind.Answer ? AnswerScope : ReadScope;
|
||||
if (!token.Scopes.Contains(scope, StringComparer.Ordinal))
|
||||
{
|
||||
await WriteRefusalAsync(http, DeskRefusals.InsufficientScope);
|
||||
return;
|
||||
}
|
||||
|
||||
// 5. Active membership, re-read now; the body has not been touched.
|
||||
Guid? accountId;
|
||||
try
|
||||
{
|
||||
accountId = await OidcEndpoints.ActiveMemberIdAsync(db, token.Subject, cancellationToken);
|
||||
}
|
||||
catch (Exception) when (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
return;
|
||||
}
|
||||
|
||||
if (accountId is null)
|
||||
{
|
||||
await WriteRefusalAsync(http, DeskRefusals.Forbidden);
|
||||
return;
|
||||
}
|
||||
|
||||
// 6. The request's shape. An answer's bytes are the bytes forwarded; list and read judge their query.
|
||||
byte[] body = [];
|
||||
DeskListRequest? listRequest = null;
|
||||
var forkId = string.Empty;
|
||||
if (route.Kind == DeskRouteKind.Answer)
|
||||
{
|
||||
var read = await ReadBodyAsync(http.Request, desk.MaxBodyBytes, cancellationToken);
|
||||
var verdict = read is null
|
||||
? DeskBodyVerdict.Refuse(DeskRefusals.BodyInvalid)
|
||||
: DeskBodyShape.Judge(read, desk.MaxBodyBytes);
|
||||
if (verdict.RefusalCode is not null)
|
||||
{
|
||||
await WriteRefusalAsync(http, verdict.RefusalCode);
|
||||
return;
|
||||
}
|
||||
|
||||
body = read!;
|
||||
}
|
||||
else if (route.Kind == DeskRouteKind.Read
|
||||
? !DeskQuery.TryRead(route.RawQuery, route.RawFork!, out forkId)
|
||||
: !DeskQuery.TryList(route.RawQuery, string.Empty, out listRequest))
|
||||
{
|
||||
await WriteRefusalAsync(http, DeskRefusals.RequestInvalid);
|
||||
return;
|
||||
}
|
||||
|
||||
// 7. The {mind} lookup: a miss is the same document as an unknown fork.
|
||||
var mind = minds.Resolve(route.RawMind);
|
||||
if (mind is null)
|
||||
{
|
||||
await WriteRefusalAsync(http, DeskRefusals.ForkUnknown);
|
||||
return;
|
||||
}
|
||||
|
||||
// 8-10. The door. A decider list outside 1..64 unique ids is a configuration fault: nothing is sent.
|
||||
if (!DeskMindOptions.DecidersWithinBounds(mind.Deciders))
|
||||
{
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
return;
|
||||
}
|
||||
|
||||
var subject = accountId.Value.ToString("D");
|
||||
var context = new DeskDoorContext(mind.Id, desk.Attribution.AuthorityOf(subject), subject, mind.Deciders.ToArray());
|
||||
try
|
||||
{
|
||||
switch (route.Kind)
|
||||
{
|
||||
case DeskRouteKind.List:
|
||||
var listed = await door.ListAsync(mind.Socket, context, listRequest! with { Mind = mind.Id }, cancellationToken);
|
||||
if (listed is DeskListOutcome.Listed(var list))
|
||||
{
|
||||
await WriteJsonAsync(http, 200, IsDecider(context) ? list : DeskNotes.Strip(list));
|
||||
}
|
||||
else if (listed is DeskListOutcome.ForkTooLarge(var largeId, var largeOrder))
|
||||
{
|
||||
await WriteJsonAsync(http, DeskRefusals.ForkTooLargeStatus, DeskRefusals.ForkTooLargeDocument(largeId, largeOrder));
|
||||
}
|
||||
else if (listed is DeskListOutcome.NotListed(var listCode) && DoorMayRefuse(listCode) && listCode != DeskRefusals.RequestIdConflict)
|
||||
{
|
||||
await WriteRefusalAsync(http, ReadListCode(listCode));
|
||||
}
|
||||
else
|
||||
{
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
}
|
||||
|
||||
return;
|
||||
case DeskRouteKind.Read:
|
||||
var found = await door.ReadAsync(mind.Socket, context, forkId, cancellationToken);
|
||||
if (found is DeskReadOutcome.Found(var entry))
|
||||
{
|
||||
await WriteJsonAsync(http, 200, IsDecider(context) ? entry : DeskNotes.Strip(entry));
|
||||
}
|
||||
else if (found is DeskReadOutcome.NotFound(var readCode) && DoorMayRefuse(readCode) && readCode != DeskRefusals.RequestIdConflict)
|
||||
{
|
||||
await WriteRefusalAsync(http, ReadListCode(readCode));
|
||||
}
|
||||
else
|
||||
{
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
}
|
||||
|
||||
return;
|
||||
default:
|
||||
await AnswerAsync(http, door, mind, context, body, desk);
|
||||
return;
|
||||
}
|
||||
}
|
||||
catch (Exception) when (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
}
|
||||
}
|
||||
|
||||
private static async Task AnswerAsync(
|
||||
HttpContext http, IDeskDoor door, DeskMindOptions mind, DeskDoorContext context, byte[] body, DeskOptions desk)
|
||||
{
|
||||
var cancellationToken = http.RequestAborted;
|
||||
var outcome = await door.AnswerAsync(mind.Socket, context, body, cancellationToken);
|
||||
switch (outcome)
|
||||
{
|
||||
case DeskAnswerOutcome.NotStored(var code) when DoorMayRefuse(code):
|
||||
await WriteRefusalAsync(http, code);
|
||||
return;
|
||||
case DeskAnswerOutcome.Answered(var result) when DeskStatus.Of(result) is { } status:
|
||||
// A stale_fork answer, fresh or replayed, carries the CURRENT card: nothing is stored for it.
|
||||
if (string.Equals(result.Answer.Code, DeskStatus.StaleFork, StringComparison.Ordinal))
|
||||
{
|
||||
var current = await door.ReadAsync(mind.Socket, context, result.Answer.ForkId, cancellationToken);
|
||||
if (current is not DeskReadOutcome.Found(var entry))
|
||||
{
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
return;
|
||||
}
|
||||
|
||||
result = result with { Card = entry.Card };
|
||||
}
|
||||
|
||||
await WriteJsonAsync(http, status, result);
|
||||
return;
|
||||
default:
|
||||
await WriteUnavailableAsync(http, desk);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// A note is a decider's own words: only a caller on the admin-set list reads them (visibility ruling c).
|
||||
private static bool IsDecider(DeskDoorContext context) =>
|
||||
context.Deciders.Contains(context.Subject, StringComparer.Ordinal);
|
||||
|
||||
// Codes the door may hand back for nothing stored. The three the edge alone judges are never the door's.
|
||||
private static bool DoorMayRefuse(string code) =>
|
||||
code is not (DeskRefusals.Unauthenticated or DeskRefusals.InsufficientScope or DeskRefusals.Forbidden) &&
|
||||
DeskRefusals.IsKnown(code);
|
||||
|
||||
// request_id_conflict is the answer's alone (Libby): a read or list carries no request_id, so the door saying it
|
||||
// there is a door fault and the edge says `unavailable`.
|
||||
// A read or list sends no body. A door that refuses one for its body (an `authority` field among them) is
|
||||
// refusing the request, which is request_invalid; it is not an outage.
|
||||
private static string ReadListCode(string code) =>
|
||||
code is DeskRefusals.BodyForbiddenField or DeskRefusals.BodyUnknownField or DeskRefusals.BodyInvalid
|
||||
? DeskRefusals.RequestInvalid
|
||||
: code;
|
||||
|
||||
// At most `cap` bytes. Null when the body is longer, judged by Content-Length first and then while reading.
|
||||
private static async Task<byte[]?> ReadBodyAsync(HttpRequest request, int cap, CancellationToken cancellationToken)
|
||||
{
|
||||
if (request.ContentLength > cap)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
using var buffer = new MemoryStream();
|
||||
var chunk = new byte[4096];
|
||||
int count;
|
||||
while ((count = await request.Body.ReadAsync(chunk, cancellationToken)) > 0)
|
||||
{
|
||||
if (buffer.Length + count > cap)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
buffer.Write(chunk, 0, count);
|
||||
}
|
||||
|
||||
return buffer.ToArray();
|
||||
}
|
||||
|
||||
private static Task WriteRefusalAsync(HttpContext http, string code) =>
|
||||
WriteJsonAsync(http, DeskRefusals.StatusOf(code), DeskRefusals.Document(code));
|
||||
|
||||
private static async Task WriteUnavailableAsync(HttpContext http, DeskOptions desk)
|
||||
{
|
||||
http.Response.Headers.RetryAfter = desk.RetryAfterSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
||||
await WriteJsonAsync(http, DeskUnavailables.Status, DeskUnavailables.Document(desk.RetryAfterSeconds));
|
||||
}
|
||||
|
||||
private static async Task WriteJsonAsync<T>(HttpContext http, int status, T document)
|
||||
{
|
||||
http.Response.StatusCode = status;
|
||||
http.Response.ContentType = "application/json; charset=utf-8";
|
||||
await JsonSerializer.SerializeAsync(http.Response.Body, document, DeskJson.Options, http.RequestAborted);
|
||||
}
|
||||
}
|
||||
|
||||
// The one place a stored outcome becomes an HTTP status. fork-card.md prose says 200 for any stored outcome; the
|
||||
// vectors (results[].httpStatus) say a Refused answer carries its refusal's status, and the vectors are the check.
|
||||
public static class DeskStatus
|
||||
{
|
||||
public const string StaleFork = "stale_fork";
|
||||
|
||||
private static readonly Dictionary<string, int> RefusedStatus = new(StringComparer.Ordinal)
|
||||
{
|
||||
[StaleFork] = 409,
|
||||
["not_a_decider"] = 403,
|
||||
["fork_closed"] = 409,
|
||||
["choice_invalid"] = 400,
|
||||
["bad_retraction"] = 400,
|
||||
["already_retracted"] = 409,
|
||||
};
|
||||
|
||||
// Null when the door sent an outcome or a refusal code this contract does not name: Bifrost then cannot vouch
|
||||
// for it and says `unavailable`.
|
||||
public static int? Of(AnswerResult result) => result.Answer.Outcome switch
|
||||
{
|
||||
"Counted" or "Revision" or "Retraction" => 200,
|
||||
"Refused" when result.Answer.Code is { } code && RefusedStatus.TryGetValue(code, out var status) => status,
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
|
||||
public enum DeskRouteKind
|
||||
{
|
||||
List,
|
||||
Read,
|
||||
Answer,
|
||||
}
|
||||
|
||||
public sealed record DeskRoute(DeskRouteKind Kind, string RawMind, string? RawFork, string RawQuery)
|
||||
{
|
||||
// The raw request target against the three routes. Segments stay percent-encoded: {mind} is decoded once, by
|
||||
// the resolver, and nothing here normalises a dot segment. Any other shape is not a desk route.
|
||||
public static DeskRoute? Parse(string method, string rawTarget)
|
||||
{
|
||||
var path = rawTarget;
|
||||
var query = string.Empty;
|
||||
var split = path.IndexOf('?');
|
||||
if (split >= 0)
|
||||
{
|
||||
query = path[(split + 1)..];
|
||||
path = path[..split];
|
||||
}
|
||||
|
||||
if (!path.StartsWith(DeskEndpoints.RoutePrefix + "/", StringComparison.Ordinal))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var segments = path[(DeskEndpoints.RoutePrefix.Length + 1)..].Split('/');
|
||||
return (method, segments) switch
|
||||
{
|
||||
("GET", [var mind, "forks"]) => new DeskRoute(DeskRouteKind.List, mind, null, query),
|
||||
("GET", [var mind, "forks", var fork]) => new DeskRoute(DeskRouteKind.Read, mind, fork, query),
|
||||
("POST", [var mind, "answers"]) => new DeskRoute(DeskRouteKind.Answer, mind, null, query),
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// The list and read requests the query string and path stand for (fork-card.md, List and Read). Nothing in a
|
||||
// query sets a decider, an answerer or a Mind; an unknown key, a repeated key or a bad value is request_invalid.
|
||||
public static class DeskQuery
|
||||
{
|
||||
public const int MaxLimit = 50;
|
||||
|
||||
public static bool TryList(string rawQuery, string mind, out DeskListRequest request)
|
||||
{
|
||||
request = new DeskListRequest(mind, null, null, MaxLimit);
|
||||
if (!TryPairs(rawQuery, out var pairs))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
string? status = null, cursor = null;
|
||||
var limit = MaxLimit;
|
||||
foreach (var (key, value) in pairs)
|
||||
{
|
||||
switch (key)
|
||||
{
|
||||
case "status" when value is "open" or "recorded":
|
||||
status = value;
|
||||
break;
|
||||
case "status" when value.Length == 0:
|
||||
break;
|
||||
case "cursor" when IsCursor(value):
|
||||
cursor = value;
|
||||
break;
|
||||
case "cursor" when value.Length == 0:
|
||||
break;
|
||||
case "limit" when int.TryParse(value, System.Globalization.NumberStyles.None, System.Globalization.CultureInfo.InvariantCulture, out var n) && n <= MaxLimit:
|
||||
limit = n;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
request = new DeskListRequest(mind, status, cursor, limit);
|
||||
return true;
|
||||
}
|
||||
|
||||
// The read request has no query at all.
|
||||
public static bool TryRead(string rawQuery, string rawFork, out string forkId)
|
||||
{
|
||||
forkId = string.Empty;
|
||||
return rawQuery.Length == 0 && DeskMindRoutes.TryDecode(rawFork, out forkId) && forkId.Length > 0;
|
||||
}
|
||||
|
||||
// c<N>, N a positive integer without a leading zero.
|
||||
private static bool IsCursor(string value) =>
|
||||
value.Length > 1 && value[0] == 'c' && value[1] is >= '1' and <= '9' && value.Skip(2).All(char.IsAsciiDigit);
|
||||
|
||||
private static bool TryPairs(string rawQuery, out List<(string Key, string Value)> pairs)
|
||||
{
|
||||
pairs = [];
|
||||
var seen = new HashSet<string>(StringComparer.Ordinal);
|
||||
if (rawQuery.Length == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
foreach (var part in rawQuery.Split('&'))
|
||||
{
|
||||
var eq = part.IndexOf('=');
|
||||
var rawKey = eq < 0 ? part : part[..eq];
|
||||
var rawValue = eq < 0 ? string.Empty : part[(eq + 1)..];
|
||||
if (!DeskMindRoutes.TryDecode(rawKey, out var key) || !DeskMindRoutes.TryDecode(rawValue, out var value) || !seen.Add(key))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
pairs.Add((key, value));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
84
src/Bifrost.Web/Features/Desk/DeskMindRoutes.cs
Normal file
84
src/Bifrost.Web/Features/Desk/DeskMindRoutes.cs
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
using System.Text;
|
||||
using Bifrost.Web.Configuration;
|
||||
|
||||
namespace Bifrost.Web.Features.Desk;
|
||||
|
||||
// The {mind} segment of a desk route (fork-card.md M1). The raw segment is percent-decoded once and compared,
|
||||
// ordinally, with the configured ids: no case folding, trimming or normalisation, and a decoding failure is a miss.
|
||||
// The segment is never joined into a path, a socket name or a query, so a value off the list opens nothing.
|
||||
public sealed class DeskMindRoutes
|
||||
{
|
||||
private static readonly UTF8Encoding StrictUtf8 = new(false, true);
|
||||
|
||||
private readonly Dictionary<string, DeskMindOptions> byId;
|
||||
|
||||
public DeskMindRoutes(IEnumerable<DeskMindOptions> minds)
|
||||
{
|
||||
byId = new Dictionary<string, DeskMindOptions>(StringComparer.Ordinal);
|
||||
foreach (var mind in minds)
|
||||
{
|
||||
byId.Add(mind.Id, mind);
|
||||
}
|
||||
}
|
||||
|
||||
public DeskMindOptions? Resolve(string rawSegment) =>
|
||||
TryDecode(rawSegment, out var id) && byId.TryGetValue(id, out var mind) ? mind : null;
|
||||
|
||||
// One pass of percent-decoding. Uri.UnescapeDataString is not used: it leaves a bad escape in place and turns
|
||||
// bytes that are not UTF-8 into U+FFFD instead of failing.
|
||||
internal static bool TryDecode(string raw, out string decoded)
|
||||
{
|
||||
decoded = string.Empty;
|
||||
var bytes = new List<byte>(raw.Length);
|
||||
for (var i = 0; i < raw.Length; i++)
|
||||
{
|
||||
var c = raw[i];
|
||||
if (c == '%')
|
||||
{
|
||||
if (i + 2 >= raw.Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!TryHex(raw[i + 1], out var high) || !TryHex(raw[i + 2], out var low))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bytes.Add((byte)((high << 4) | low));
|
||||
i += 2;
|
||||
}
|
||||
else if (c > 0x7f)
|
||||
{
|
||||
// A raw request target is ASCII; anything else is not a segment this desk issues.
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
bytes.Add((byte)c);
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
decoded = StrictUtf8.GetString(bytes.ToArray());
|
||||
return true;
|
||||
}
|
||||
catch (DecoderFallbackException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static bool TryHex(char c, out int value)
|
||||
{
|
||||
value = c switch
|
||||
{
|
||||
>= '0' and <= '9' => c - '0',
|
||||
>= 'a' and <= 'f' => c - 'a' + 10,
|
||||
>= 'A' and <= 'F' => c - 'A' + 10,
|
||||
_ => -1,
|
||||
};
|
||||
return value >= 0;
|
||||
}
|
||||
}
|
||||
67
src/Bifrost.Web/Features/Desk/DeskPorts.cs
Normal file
67
src/Bifrost.Web/Features/Desk/DeskPorts.cs
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
namespace Bifrost.Web.Features.Desk;
|
||||
|
||||
// The two ports the desk stands on. Bifrost owns the edge's order and judgments; these two own what is not
|
||||
// Bifrost's yet: validating a bearer token (the OIDC validation scheme) and speaking to a Mind's Huginn on the
|
||||
// peer-checked door. No production implementation is registered here: with the Desk section configured and a port
|
||||
// missing, startup fails (DeskEndpoints.MapDesk) instead of serving.
|
||||
|
||||
// What a validated bearer token claims. The credential port verifies the token; the desk judges audience, scope and
|
||||
// membership. A null Subject or Audience means the token did not carry one.
|
||||
public sealed record DeskToken(string? Subject, string? Audience, IReadOnlyCollection<string> Scopes);
|
||||
|
||||
public interface IDeskCredential
|
||||
{
|
||||
// Null when the request carries no valid bearer token.
|
||||
ValueTask<DeskToken?> AuthenticateAsync(HttpContext context, CancellationToken cancellationToken);
|
||||
}
|
||||
|
||||
// The envelope sent with every answer, read and list call (fork-card.md M5), under the contract's names, built by
|
||||
// Bifrost alone: the route's configured Mind id, the verified account's authority (Operator, Steward or Member),
|
||||
// the account id, and the admin-set decider list of that Mind (1 to 64 unique ids). Nothing in the request sets any
|
||||
// of it, and Huginn keeps no copy of the list.
|
||||
public sealed record DeskDoorContext(string Mind, string Authority, string Subject, IReadOnlyList<string> Deciders);
|
||||
|
||||
public abstract record DeskAnswerOutcome
|
||||
{
|
||||
// Huginn stored an outcome (Counted, Revision, Retraction or Refused) and returned its document.
|
||||
public sealed record Answered(AnswerResult Result) : DeskAnswerOutcome;
|
||||
|
||||
// Nothing stored: Huginn refused with one of the contract's refusal codes.
|
||||
public sealed record NotStored(string Code) : DeskAnswerOutcome;
|
||||
}
|
||||
|
||||
public abstract record DeskReadOutcome
|
||||
{
|
||||
public sealed record Found(ForkEntry Entry) : DeskReadOutcome;
|
||||
|
||||
public sealed record NotFound(string Code) : DeskReadOutcome;
|
||||
}
|
||||
|
||||
// The list request the desk's query string stands for. Mind is the route's, resolved against the configured list.
|
||||
public sealed record DeskListRequest(string Mind, string? Status, string? Cursor, int Limit);
|
||||
|
||||
public abstract record DeskListOutcome
|
||||
{
|
||||
public sealed record Listed(ForkList List) : DeskListOutcome;
|
||||
|
||||
public sealed record NotListed(string Code) : DeskListOutcome;
|
||||
|
||||
// The next fork is too large for any page: the page holds nothing past the cursor. The client continues with
|
||||
// cursor c<Order>; at Order 0 it has reached the end. List only: no other call can be refused this way.
|
||||
public sealed record ForkTooLarge(string ForkId, int Order) : DeskListOutcome;
|
||||
}
|
||||
|
||||
public interface IDeskDoor
|
||||
{
|
||||
// The body is exactly the bytes the client sent. Any exception means the outcome is not confirmed.
|
||||
Task<DeskAnswerOutcome> AnswerAsync(
|
||||
string socket, DeskDoorContext context, ReadOnlyMemory<byte> body, CancellationToken cancellationToken);
|
||||
|
||||
// The entry for one fork, its card built and hashed by Huginn.
|
||||
Task<DeskReadOutcome> ReadAsync(
|
||||
string socket, DeskDoorContext context, string forkId, CancellationToken cancellationToken);
|
||||
|
||||
// A page of entries, the counts and the stamp, as Huginn projects them for this viewer.
|
||||
Task<DeskListOutcome> ListAsync(
|
||||
string socket, DeskDoorContext context, DeskListRequest request, CancellationToken cancellationToken);
|
||||
}
|
||||
|
|
@ -117,18 +117,22 @@ public static class OidcEndpoints
|
|||
return Results.Json(claims);
|
||||
}
|
||||
|
||||
/// <summary>The one reading of "this subject is still an Active member", shared by the token and userinfo endpoints and the logout reconciler.</summary>
|
||||
internal static async Task<bool> IsStillActiveMemberAsync(BifrostDbContext db, string? subject, CancellationToken cancellationToken)
|
||||
/// <summary>The one reading of "this subject is still an Active member", shared by the token and userinfo endpoints, the logout reconciler and the fork desk.</summary>
|
||||
internal static async Task<bool> IsStillActiveMemberAsync(BifrostDbContext db, string? subject, CancellationToken cancellationToken) =>
|
||||
await ActiveMemberIdAsync(db, subject, cancellationToken) is not null;
|
||||
|
||||
/// <summary>The account id of the subject when it is an Active member now, else null. Re-read on every call.</summary>
|
||||
internal static async Task<Guid?> ActiveMemberIdAsync(BifrostDbContext db, string? subject, CancellationToken cancellationToken)
|
||||
{
|
||||
if (!Guid.TryParse(subject, out var accountId))
|
||||
{
|
||||
return false;
|
||||
return null;
|
||||
}
|
||||
|
||||
var account = await db.UserAccounts.AsNoTracking()
|
||||
.Include(x => x.Membership)
|
||||
.SingleOrDefaultAsync(x => x.Id == accountId, cancellationToken);
|
||||
return new CurrentBifrostActor(true, account).IsActiveMember;
|
||||
return new CurrentBifrostActor(true, account).IsActiveMember ? accountId : null;
|
||||
}
|
||||
|
||||
private static IResult Deny(string error, string description) =>
|
||||
|
|
|
|||
|
|
@ -12,7 +12,8 @@ public sealed class StartupConfigurationValidator(
|
|||
IOptions<HeimdallOptions> heimdallOptions,
|
||||
IOptions<StripeOptions> stripeOptions,
|
||||
IOptions<BifrostHostOptions> hostOptions,
|
||||
IOptions<ConceptVoteOptions> conceptVoteOptions)
|
||||
IOptions<ConceptVoteOptions> conceptVoteOptions,
|
||||
IOptions<DeskOptions> deskOptions)
|
||||
{
|
||||
public void Validate()
|
||||
{
|
||||
|
|
@ -45,6 +46,8 @@ public sealed class StartupConfigurationValidator(
|
|||
failures.Add("ConceptVotes:MaxTrackedKeys must be at least 1.");
|
||||
}
|
||||
|
||||
ValidateDesk(deskOptions.Value, failures);
|
||||
|
||||
if (hostEnvironment.IsDevelopment() || hostEnvironment.IsEnvironment("Testing"))
|
||||
{
|
||||
Refuse(failures);
|
||||
|
|
@ -116,6 +119,106 @@ public sealed class StartupConfigurationValidator(
|
|||
Refuse(failures);
|
||||
}
|
||||
|
||||
// Checked in every environment: a bad Mind list or decider id would otherwise pass startup and misroute or
|
||||
// mis-attribute answers. Account existence is a request-time question, not a startup one.
|
||||
private void ValidateDesk(DeskOptions desk, List<string> failures)
|
||||
{
|
||||
if (!desk.IsConfigured)
|
||||
{
|
||||
if (configuration.GetSection(DeskOptions.SectionName).Exists())
|
||||
{
|
||||
failures.Add("Desk:Minds must list at least one Mind when the Desk section exists.");
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (!Uri.TryCreate(desk.AllowedOrigin, UriKind.Absolute, out var origin) ||
|
||||
origin.Scheme is not ("http" or "https") ||
|
||||
!string.Equals(desk.AllowedOrigin, origin.GetLeftPart(UriPartial.Authority), StringComparison.Ordinal))
|
||||
{
|
||||
failures.Add("Desk:AllowedOrigin must be one http(s) origin: scheme, host and optional port, no path.");
|
||||
}
|
||||
|
||||
if (desk.MaxBodyBytes < 1)
|
||||
{
|
||||
failures.Add("Desk:MaxBodyBytes must be at least 1.");
|
||||
}
|
||||
|
||||
if (desk.RetryAfterSeconds < 1)
|
||||
{
|
||||
failures.Add("Desk:RetryAfterSeconds must be at least 1.");
|
||||
}
|
||||
|
||||
var ids = new HashSet<string>(StringComparer.Ordinal);
|
||||
var sockets = new HashSet<string>(StringComparer.Ordinal);
|
||||
for (var i = 0; i < desk.Minds.Count; i++)
|
||||
{
|
||||
var mind = desk.Minds[i];
|
||||
if (string.IsNullOrWhiteSpace(mind.Id))
|
||||
{
|
||||
failures.Add($"Desk:Minds:{i}:Id must not be blank.");
|
||||
}
|
||||
else if (!ids.Add(mind.Id))
|
||||
{
|
||||
failures.Add($"Desk:Minds:{i}:Id repeats an earlier Mind id.");
|
||||
}
|
||||
|
||||
if (!Path.IsPathFullyQualified(mind.Socket))
|
||||
{
|
||||
failures.Add($"Desk:Minds:{i}:Socket must be an absolute path.");
|
||||
}
|
||||
else if (!sockets.Add(mind.Socket))
|
||||
{
|
||||
failures.Add($"Desk:Minds:{i}:Socket repeats an earlier Mind's socket.");
|
||||
}
|
||||
|
||||
if (mind.Deciders.Count is < 1 or > DeskMindOptions.MaxDeciders)
|
||||
{
|
||||
failures.Add($"Desk:Minds:{i}:Deciders must hold 1 to {DeskMindOptions.MaxDeciders} account ids.");
|
||||
}
|
||||
|
||||
var deciders = new HashSet<string>(StringComparer.Ordinal);
|
||||
foreach (var decider in mind.Deciders)
|
||||
{
|
||||
if (!IsLowercaseGuid(decider))
|
||||
{
|
||||
failures.Add($"Desk:Minds:{i}:Deciders entries must be lowercase D-format account ids.");
|
||||
}
|
||||
else if (!deciders.Add(decider))
|
||||
{
|
||||
failures.Add($"Desk:Minds:{i}:Deciders repeats an account id.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var attribution = desk.Attribution;
|
||||
if (!string.IsNullOrEmpty(attribution.Operator) && !IsLowercaseGuid(attribution.Operator))
|
||||
{
|
||||
failures.Add("Desk:Attribution:Operator must be a lowercase D-format account id.");
|
||||
}
|
||||
|
||||
var stewards = new HashSet<string>(StringComparer.Ordinal);
|
||||
foreach (var steward in attribution.Stewards)
|
||||
{
|
||||
if (!IsLowercaseGuid(steward))
|
||||
{
|
||||
failures.Add("Desk:Attribution:Stewards entries must be lowercase D-format account ids.");
|
||||
}
|
||||
else if (!stewards.Add(steward))
|
||||
{
|
||||
failures.Add("Desk:Attribution:Stewards repeats an account id.");
|
||||
}
|
||||
else if (string.Equals(steward, attribution.Operator, StringComparison.Ordinal))
|
||||
{
|
||||
failures.Add("Desk:Attribution:Operator must not also be a steward.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static bool IsLowercaseGuid(string? value) =>
|
||||
Guid.TryParseExact(value, "D", out var guid) && string.Equals(value, guid.ToString("D"), StringComparison.Ordinal);
|
||||
|
||||
private static void Refuse(List<string> failures)
|
||||
{
|
||||
if (failures.Count > 0)
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ using Bifrost.Web.Data;
|
|||
using Bifrost.Web.Domain;
|
||||
using Bifrost.Web.Features.Bridge;
|
||||
using Bifrost.Web.Features.ConceptVotes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Features.GitHub;
|
||||
using Bifrost.Web.Features.Heimdall;
|
||||
using Bifrost.Web.Features.Membership;
|
||||
|
|
@ -76,6 +77,10 @@ builder.Services
|
|||
.AddOptions<ConceptVoteOptions>()
|
||||
.BindConfiguration(ConceptVoteOptions.SectionName);
|
||||
|
||||
builder.Services
|
||||
.AddOptions<DeskOptions>()
|
||||
.BindConfiguration(DeskOptions.SectionName);
|
||||
|
||||
builder.Services.AddAntiforgery(options =>
|
||||
{
|
||||
options.Cookie.Name = BifrostCookies.Antiforgery;
|
||||
|
|
@ -252,6 +257,13 @@ if (oidcOptions is not null)
|
|||
builder.Services.AddBifrostOidc(oidcOptions);
|
||||
}
|
||||
|
||||
// The desk is mapped only when the Desk section exists, and a configured desk needs its credential and door ports.
|
||||
var deskConfigured = builder.Configuration.GetSection(DeskOptions.SectionName).Exists();
|
||||
if (deskConfigured)
|
||||
{
|
||||
builder.Services.AddBifrostDesk();
|
||||
}
|
||||
|
||||
var app = builder.Build();
|
||||
var appJsonSerializerOptions = CreateAppJsonSerializerOptions();
|
||||
|
||||
|
|
@ -300,6 +312,11 @@ if (oidcOptions is not null)
|
|||
app.MapBifrostOidc();
|
||||
}
|
||||
|
||||
if (deskConfigured)
|
||||
{
|
||||
app.MapDesk();
|
||||
}
|
||||
|
||||
app.MapPost("/github/webhooks", async (
|
||||
HttpRequest request,
|
||||
GitHubWebhookService gitHubWebhookService,
|
||||
|
|
|
|||
203
tests/Bifrost.Web.Tests/DeskAnswerTests.cs
Normal file
203
tests/Bifrost.Web.Tests/DeskAnswerTests.cs
Normal file
|
|
@ -0,0 +1,203 @@
|
|||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskAnswerTests
|
||||
{
|
||||
private static readonly string Socket = DeskWebApplicationFactory.SocketOf("gamecult-chat");
|
||||
|
||||
private static async Task<(DeskWebApplicationFactory Factory, string Token)> ArrangeAsync()
|
||||
{
|
||||
var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
return (factory, factory.Token(DeskWebApplicationFactory.Alice, "bifrost-desk", "desk.answer"));
|
||||
}
|
||||
|
||||
private static AnswerResult Stale(string forkId) => new(
|
||||
DeskSchemas.AnswerResult,
|
||||
new DeskAnswerDocument(
|
||||
DeskSchemas.DeskAnswer, "n1", forkId, "Refused", null, null, "stale_fork", "oldhash", "no", null,
|
||||
"2026-11-12T19:02:00Z", "2026-11-12T19:02:05Z", false, DeskWebApplicationFactory.Alice, "Operator",
|
||||
"00000001-0000-4000-8000-000000000001"),
|
||||
null,
|
||||
null);
|
||||
|
||||
[Fact]
|
||||
public async Task Stale_fork_attaches_current_card_fresh_and_replayed()
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
factory.Door.AnswerScript = (_, _, _) => new DeskAnswerOutcome.Answered(Stale(DeskReplay.ChatFork));
|
||||
var target = DeskReplay.Target("answer", "gamecult-chat", null);
|
||||
|
||||
factory.Door.Forks[(Socket, DeskReplay.ChatFork)] = DeskReplay.Entry(DeskReplay.Card(DeskReplay.ChatFork, "first card"));
|
||||
var fresh = await factory.SendAsync("POST", target, DeskReplay.AnswerBody(DeskReplay.ChatFork), token);
|
||||
|
||||
// The same stored answer is replayed after the card changed: nothing is stored for the card, so the reply carries the new one.
|
||||
factory.Door.Forks[(Socket, DeskReplay.ChatFork)] = DeskReplay.Entry(DeskReplay.Card(DeskReplay.ChatFork, "second card"));
|
||||
var replayed = await factory.SendAsync("POST", target, DeskReplay.AnswerBody(DeskReplay.ChatFork), token);
|
||||
|
||||
Assert.Equal(409, fresh.Status);
|
||||
Assert.Equal("first card", (string?)JsonNode.Parse(fresh.Body)!["card"]!["title"]);
|
||||
Assert.Equal(409, replayed.Status);
|
||||
Assert.Equal("second card", (string?)JsonNode.Parse(replayed.Body)!["card"]!["title"]);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_refusal_that_is_not_stale_carries_no_card_and_asks_no_read()
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
var closed = Stale(DeskReplay.ChatFork);
|
||||
factory.Door.AnswerScript = (_, _, _) => new DeskAnswerOutcome.Answered(closed with { Answer = closed.Answer with { Code = "fork_closed" } });
|
||||
var reply = await factory.SendAsync("POST", DeskReplay.Target("answer", "gamecult-chat", null), DeskReplay.AnswerBody(DeskReplay.ChatFork), token);
|
||||
|
||||
Assert.Equal(409, reply.Status);
|
||||
Assert.Null(JsonNode.Parse(reply.Body)!["card"]);
|
||||
Assert.DoesNotContain(factory.Door.Calls, c => c.Kind == "read");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Card_read_failure_is_unavailable()
|
||||
{
|
||||
foreach (var failure in new[] { "throws", "refuses" })
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
factory.Door.AnswerScript = (_, _, _) => new DeskAnswerOutcome.Answered(Stale(DeskReplay.ChatFork));
|
||||
factory.Door.ThrowOnRead = failure == "throws";
|
||||
// "refuses": no fork held, so the read answers fork_unknown
|
||||
|
||||
var reply = await factory.SendAsync("POST", DeskReplay.Target("answer", "gamecult-chat", null), DeskReplay.AnswerBody(DeskReplay.ChatFork), token);
|
||||
|
||||
Assert.True(503 == reply.Status, failure);
|
||||
Assert.Equal("unavailable", (string?)JsonNode.Parse(reply.Body)!["code"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task The_body_reaches_the_door_byte_for_byte()
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
// Whitespace, escapes and key spacing a re-serialiser would normalise.
|
||||
var compact = Encoding.UTF8.GetString(DeskReplay.AnswerBody(DeskReplay.ChatFork));
|
||||
var odd = compact.Replace("{", "{ \n\t", StringComparison.Ordinal).Replace(",\"", " ,\r\n \"", StringComparison.Ordinal)
|
||||
.Replace("Keep", "\\u004beep", StringComparison.Ordinal) + " \n";
|
||||
var bytes = Encoding.UTF8.GetBytes(odd);
|
||||
|
||||
var reply = await factory.SendAsync("POST", DeskReplay.Target("answer", "gamecult-chat", null), bytes, token);
|
||||
|
||||
Assert.Equal(200, reply.Status);
|
||||
Assert.Equal(bytes, Assert.Single(factory.Door.Calls).Body);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task The_door_context_comes_from_the_account_and_the_configuration_never_the_request()
|
||||
{
|
||||
var (factory, _) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Steward, true);
|
||||
var token = factory.Token(DeskWebApplicationFactory.Steward.ToUpperInvariant(), "bifrost-desk", "desk.answer");
|
||||
|
||||
// Query strings and headers that name a decider or an answerer change nothing.
|
||||
var reply = await factory.SendAsync(
|
||||
"POST", DeskReplay.Target("answer", "nibu", null) + "?deciders=" + DeskWebApplicationFactory.Member + "&answerer=x",
|
||||
DeskReplay.AnswerBody("nibu:question:glow-order"), token,
|
||||
configure: http => http.Request.Headers["X-Deciders"] = DeskWebApplicationFactory.Member);
|
||||
|
||||
Assert.Equal(200, reply.Status);
|
||||
var call = Assert.Single(factory.Door.Calls);
|
||||
Assert.Equal(DeskWebApplicationFactory.Steward, call.Context.Subject);
|
||||
Assert.Equal("Steward", call.Context.Authority);
|
||||
Assert.Equal("nibu", call.Context.Mind);
|
||||
Assert.Equal(DeskWebApplicationFactory.DecidersOf("nibu"), call.Context.Deciders);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Body_is_judged_after_membership_and_before_the_mind()
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
// A bad body for an unknown Mind is the body's refusal; a non-Active member's bad body is forbidden.
|
||||
var bad = Encoding.UTF8.GetBytes("{\"answerer\":\"x\"}");
|
||||
var reply = await factory.SendAsync("POST", DeskReplay.Target("answer", "ghost", null), bad, token);
|
||||
Assert.Equal("body_forbidden_field", (string?)JsonNode.Parse(reply.Body)!["code"]);
|
||||
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, false);
|
||||
var forbidden = await factory.SendAsync("POST", DeskReplay.Target("answer", "ghost", null), bad, token);
|
||||
Assert.Equal("forbidden", (string?)JsonNode.Parse(forbidden.Body)!["code"]);
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Membership_is_re_read_on_every_request()
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
var target = DeskReplay.Target("answer", "gamecult-chat", null);
|
||||
Assert.Equal(200, (await factory.SendAsync("POST", target, DeskReplay.AnswerBody(DeskReplay.ChatFork), token)).Status);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, false);
|
||||
Assert.Equal(403, (await factory.SendAsync("POST", target, DeskReplay.AnswerBody(DeskReplay.ChatFork), token)).Status);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task An_oversized_body_is_refused_before_it_is_read()
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
var big = Encoding.UTF8.GetBytes("{\"x\":\"" + new string('a', 17 * 1024) + "\"}");
|
||||
var reply = await factory.SendAsync("POST", DeskReplay.Target("answer", "gamecult-chat", null), big, token);
|
||||
Assert.Equal("body_invalid", (string?)JsonNode.Parse(reply.Body)!["code"]);
|
||||
|
||||
// Chunked: no Content-Length to judge, so the cap applies while reading.
|
||||
var chunked = await factory.SendAsync(
|
||||
"POST", DeskReplay.Target("answer", "gamecult-chat", null), big, token,
|
||||
configure: http => http.Request.ContentLength = null);
|
||||
Assert.Equal("body_invalid", (string?)JsonNode.Parse(chunked.Body)!["code"]);
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_door_that_sends_a_code_the_contract_does_not_name_is_unavailable()
|
||||
{
|
||||
var (factory, token) = await ArrangeAsync();
|
||||
using (factory)
|
||||
{
|
||||
foreach (var script in new Func<DeskAnswerOutcome>[]
|
||||
{
|
||||
() => new DeskAnswerOutcome.NotStored("something_internal"),
|
||||
() => new DeskAnswerOutcome.NotStored("forbidden"),
|
||||
() => new DeskAnswerOutcome.Answered(Stale("x") with { Answer = Stale("x").Answer with { Code = "made_up" } }),
|
||||
})
|
||||
{
|
||||
factory.Door.AnswerScript = (_, _, _) => script();
|
||||
var reply = await factory.SendAsync("POST", DeskReplay.Target("answer", "gamecult-chat", null), DeskReplay.AnswerBody(DeskReplay.ChatFork), token);
|
||||
Assert.Equal(503, reply.Status);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
49
tests/Bifrost.Web.Tests/DeskAuthCaseTests.cs
Normal file
49
tests/Bifrost.Web.Tests/DeskAuthCaseTests.cs
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskAuthCaseTests
|
||||
{
|
||||
[Fact]
|
||||
public async Task Vector_auth_cases()
|
||||
{
|
||||
var cases = DeskVectors.Rows("transport", "authCases").ToList();
|
||||
Assert.Equal(22, cases.Count);
|
||||
|
||||
foreach (var row in cases)
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
factory.Door.Down = (bool)row["huginn_down"]!;
|
||||
var token = await DeskReplay.TokenAsync(factory, row["token"]);
|
||||
|
||||
var route = (string)row["route"]!;
|
||||
var reply = await factory.SendAsync(
|
||||
route == "answer" ? "POST" : "GET", DeskReplay.Target(route, "gamecult-chat", DeskReplay.ChatFork),
|
||||
route == "answer" ? DeskReplay.AnswerBody(DeskReplay.ChatFork) : null, token);
|
||||
|
||||
var name = (string)row["name"]!;
|
||||
var expect = (string)row["expect"]!;
|
||||
var body = JsonNode.Parse(reply.Body);
|
||||
switch (expect)
|
||||
{
|
||||
case "ok":
|
||||
Assert.True(200 == reply.Status, $"{name}: {reply.Status} {reply.Text}");
|
||||
Assert.Single(factory.Door.Calls);
|
||||
break;
|
||||
case "unavailable":
|
||||
Assert.True(503 == reply.Status, $"{name}: {reply.Status}");
|
||||
Assert.True(DeskVectors.SameShape(body, JsonNode.Parse(System.Text.Json.JsonSerializer.Serialize(DeskUnavailables.Document(30), DeskJson.Options))), name);
|
||||
break;
|
||||
default:
|
||||
Assert.True(DeskRefusals.StatusOf(expect) == reply.Status, $"{name}: {reply.Status}");
|
||||
Assert.True(DeskVectors.SameShape(body, JsonNode.Parse(System.Text.Json.JsonSerializer.Serialize(DeskRefusals.Document(expect), DeskJson.Options))), name);
|
||||
// Auth, scope and membership are judged before Huginn is asked.
|
||||
Assert.True(factory.Door.Calls.Count == 0, $"{name}: the door was called");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
267
tests/Bifrost.Web.Tests/DeskBodyShapeTests.cs
Normal file
267
tests/Bifrost.Web.Tests/DeskBodyShapeTests.cs
Normal file
|
|
@ -0,0 +1,267 @@
|
|||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskBodyShapeTests
|
||||
{
|
||||
private const int Cap = 16 * 1024;
|
||||
|
||||
private static DeskBodyVerdict Judge(JsonNode body, int cap = Cap) => DeskBodyShape.Judge(DeskVectors.Bytes(body), cap);
|
||||
|
||||
private static DeskBodyVerdict Judge(string json, int cap = Cap) => DeskBodyShape.Judge(Encoding.UTF8.GetBytes(json), cap);
|
||||
|
||||
private static JsonObject ValidBody() =>
|
||||
DeskVectors.Rows("request", "valid").First(row => (string)row["name"]! == "choice_and_note")["message"]!.DeepClone().AsObject();
|
||||
|
||||
private static string ExpectedCode(string name) => name switch
|
||||
{
|
||||
"answerer_key" or "authority_key" => DeskRefusals.BodyForbiddenField,
|
||||
"answer_object_with_a_key" => DeskRefusals.BodyUnknownField,
|
||||
_ => DeskRefusals.BodyInvalid,
|
||||
};
|
||||
|
||||
public static IEnumerable<object[]> ValidRows() =>
|
||||
DeskVectors.Rows("request", "valid").Select(row => new object[] { (string)row["name"]! });
|
||||
|
||||
public static IEnumerable<object[]> InvalidRows() =>
|
||||
DeskVectors.Rows("request", "invalid").Select(row => new object[] { (string)row["name"]! });
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ValidRows))]
|
||||
public void Valid_request_vectors_pass(string name)
|
||||
{
|
||||
var message = DeskVectors.Rows("request", "valid").First(row => (string)row["name"]! == name)["message"]!;
|
||||
|
||||
var verdict = Judge(message);
|
||||
|
||||
Assert.Null(verdict.RefusalCode);
|
||||
Assert.NotNull(verdict.Request);
|
||||
// The parsed request is the document: same keys, same order, same values.
|
||||
var echoed = JsonSerializer.SerializeToNode(verdict.Request, DeskJson.Options);
|
||||
Assert.True(DeskVectors.SameShape(message, echoed), $"{name} did not round-trip: {echoed}");
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(InvalidRows))]
|
||||
public void Invalid_request_vectors_refuse_with_their_code(string name)
|
||||
{
|
||||
var message = DeskVectors.Rows("request", "invalid").First(row => (string)row["name"]! == name)["message"]!;
|
||||
|
||||
var verdict = Judge(message);
|
||||
|
||||
Assert.Null(verdict.Request);
|
||||
Assert.Equal(ExpectedCode(name), verdict.RefusalCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Forbidden_key_at_any_depth_beats_unknown_key()
|
||||
{
|
||||
foreach (var key in new[] { "answerer", "authority" })
|
||||
{
|
||||
var nested = ValidBody();
|
||||
nested["answer"]!["detail"] = new JsonObject { ["deep"] = new JsonArray(new JsonObject { [key] = "x" }) };
|
||||
nested["extra"] = 1;
|
||||
Assert.Equal(DeskRefusals.BodyForbiddenField, Judge(nested).RefusalCode);
|
||||
|
||||
var top = ValidBody();
|
||||
top["unknown"] = 1;
|
||||
top[key] = "someone";
|
||||
Assert.Equal(DeskRefusals.BodyForbiddenField, Judge(top).RefusalCode);
|
||||
|
||||
// Written with an escape: the name is the same once decoded, and still refused whole.
|
||||
var escaped = DeskVectors.Bytes(ValidBody()).ToArray();
|
||||
var text = Encoding.UTF8.GetString(escaped).TrimEnd('}') + $",\"{key[..3]}\\u{(int)key[3]:x4}{key[4..]}\":\"x\"}}";
|
||||
Assert.Equal(DeskRefusals.BodyForbiddenField, Judge(text).RefusalCode);
|
||||
}
|
||||
|
||||
// The key name is matched exactly: a near miss is only an unknown key.
|
||||
var near = ValidBody();
|
||||
near["Answerer"] = "x";
|
||||
Assert.Equal(DeskRefusals.BodyUnknownField, Judge(near).RefusalCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Mind_and_deciders_in_the_body_are_unknown_fields()
|
||||
{
|
||||
foreach (var key in new[] { "mind", "deciders" })
|
||||
{
|
||||
var body = ValidBody();
|
||||
body[key] = "x";
|
||||
Assert.Equal(DeskRefusals.BodyUnknownField, Judge(body).RefusalCode);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Illegal_retraction_forms_reach_the_door()
|
||||
{
|
||||
var forms = new (string Answer, string Retracted, string Retracts)[]
|
||||
{
|
||||
("null", "true", "null"), // a retraction with no target
|
||||
("{\"choice\":\"no\",\"note\":null}", "true", "\"n1\""), // a retraction carrying an answer
|
||||
("{\"choice\":\"no\",\"note\":null}", "false", "\"n1\""), // a plain answer with a target
|
||||
("null", "true", "\"n1\""), // the legal retraction
|
||||
};
|
||||
|
||||
foreach (var (answer, retracted, retracts) in forms)
|
||||
{
|
||||
var body = ValidBody();
|
||||
body["answer"] = JsonNode.Parse(answer);
|
||||
body["retracted"] = JsonNode.Parse(retracted);
|
||||
body["retracts"] = JsonNode.Parse(retracts);
|
||||
|
||||
var verdict = Judge(body);
|
||||
|
||||
Assert.True(verdict.RefusalCode is null, $"answer={answer} retracted={retracted} retracts={retracts}: {verdict.RefusalCode}");
|
||||
Assert.NotNull(verdict.Request);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Neither_answer_nor_retraction_is_body_invalid()
|
||||
{
|
||||
foreach (var retracts in new[] { "null", "\"n1\"" })
|
||||
{
|
||||
var body = ValidBody();
|
||||
body["answer"] = null;
|
||||
body["retracted"] = false;
|
||||
body["retracts"] = JsonNode.Parse(retracts);
|
||||
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(body).RefusalCode);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Note_limits_are_utf8_bytes()
|
||||
{
|
||||
string Note(string text) => Judge(WithNote(text)).RefusalCode ?? "pass";
|
||||
|
||||
string Repeat(string unit, int count) => string.Concat(Enumerable.Repeat(unit, count));
|
||||
var astral = char.ConvertFromUtf32(0x1F600); // 4 bytes
|
||||
var combining = "e" + (char)0x0301; // 3 bytes
|
||||
var twoByte = ((char)0xe9).ToString(); // 2 bytes
|
||||
var spaces = new string(new[] { (char)9, (char)0xa0, (char)0x3000, (char)0x2028 });
|
||||
|
||||
Assert.Equal("pass", Note(new string('x', 4000)));
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Note(new string('x', 4001)));
|
||||
Assert.Equal("pass", Note(Repeat(astral, 1000)));
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Note(Repeat(astral, 1001)));
|
||||
Assert.Equal("pass", Note(Repeat(combining, 1333) + "x"));
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Note(Repeat(combining, 1334)));
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Note(Repeat(twoByte, 1999) + "xxx"));
|
||||
Assert.Equal("pass", Note("x"));
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Note(""));
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Note(spaces));
|
||||
Assert.Equal("pass", Note(" a "));
|
||||
|
||||
static JsonNode WithNote(string text)
|
||||
{
|
||||
var body = ValidBody();
|
||||
body["answer"] = new JsonObject { ["choice"] = null, ["note"] = text };
|
||||
return body;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Lone_surrogate_in_a_note_is_body_invalid()
|
||||
{
|
||||
var json = DeskVectors.Bytes(ValidBody()).ToArray();
|
||||
var text = Encoding.UTF8.GetString(json).Replace("\"note\":\"", "\"note\":\"\\ud800");
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(text).RefusalCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Over_cap_refused_before_parse()
|
||||
{
|
||||
var body = ValidBody();
|
||||
var bytes = DeskVectors.Bytes(body);
|
||||
|
||||
Assert.Null(DeskBodyShape.Judge(bytes, bytes.Length).RefusalCode);
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, DeskBodyShape.Judge(bytes, bytes.Length - 1).RefusalCode);
|
||||
|
||||
// Over the cap the forbidden key is never found, because the body is never parsed.
|
||||
body["answerer"] = "x";
|
||||
var forbidden = DeskVectors.Bytes(body);
|
||||
Assert.Equal(DeskRefusals.BodyForbiddenField, DeskBodyShape.Judge(forbidden, forbidden.Length).RefusalCode);
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, DeskBodyShape.Judge(forbidden, forbidden.Length - 1).RefusalCode);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("")]
|
||||
[InlineData("not json")]
|
||||
[InlineData("[]")]
|
||||
[InlineData("null")]
|
||||
[InlineData("\"text\"")]
|
||||
[InlineData("{")]
|
||||
public void Non_object_or_broken_json_is_body_invalid(string json) =>
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(json).RefusalCode);
|
||||
|
||||
[Fact]
|
||||
public void Invalid_utf8_is_body_invalid()
|
||||
{
|
||||
var bytes = DeskVectors.Bytes(ValidBody());
|
||||
var bad = bytes.Take(bytes.Length - 2).Concat(new byte[] { 0xff }).Concat(bytes.Skip(bytes.Length - 2)).ToArray();
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, DeskBodyShape.Judge(bad, Cap).RefusalCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Repeated_key_is_body_invalid()
|
||||
{
|
||||
var text = Encoding.UTF8.GetString(DeskVectors.Bytes(ValidBody())).TrimEnd('}') + ",\"fork_id\":\"other\"}";
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(text).RefusalCode);
|
||||
|
||||
var answer = Encoding.UTF8.GetString(DeskVectors.Bytes(ValidBody())).Replace("\"choice\":\"no\"", "\"choice\":\"no\",\"choice\":\"yes\"");
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(answer).RefusalCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Trailing_newline_does_not_rescue_a_bad_pattern()
|
||||
{
|
||||
var body = ValidBody();
|
||||
body["request_id"] = ((string)body["request_id"]!) + "\n";
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(body).RefusalCode);
|
||||
|
||||
body = ValidBody();
|
||||
body["options_hash"] = ((string)body["options_hash"]!) + "\n";
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(body).RefusalCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Wrong_schema_version_and_bad_retracts_are_body_invalid()
|
||||
{
|
||||
var body = ValidBody();
|
||||
body["schemaVersion"] = "gamecult.fork.answer_request.v1";
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(body).RefusalCode);
|
||||
|
||||
foreach (var retracts in new[] { "n0", "n01", "x1", "n" })
|
||||
{
|
||||
body = ValidBody();
|
||||
body["answer"] = null;
|
||||
body["retracted"] = true;
|
||||
body["retracts"] = retracts;
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(body).RefusalCode);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Missing_key_is_body_invalid_for_each_key()
|
||||
{
|
||||
foreach (var key in ValidBody().Select(p => p.Key).ToList())
|
||||
{
|
||||
var body = ValidBody();
|
||||
body.Remove(key);
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(body).RefusalCode);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Answer_object_must_hold_both_keys()
|
||||
{
|
||||
var body = ValidBody();
|
||||
body["answer"] = new JsonObject { ["choice"] = "no" };
|
||||
Assert.Equal(DeskRefusals.BodyInvalid, Judge(body).RefusalCode);
|
||||
}
|
||||
}
|
||||
67
tests/Bifrost.Web.Tests/DeskDocumentTests.cs
Normal file
67
tests/Bifrost.Web.Tests/DeskDocumentTests.cs
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskDocumentTests
|
||||
{
|
||||
private static JsonNode? Write<T>(T document) => JsonSerializer.SerializeToNode(document, DeskJson.Options);
|
||||
|
||||
[Fact]
|
||||
public void Refusal_and_unavailable_documents_match_vectors()
|
||||
{
|
||||
var rows = DeskVectors.Rows("doorRefusals").ToList();
|
||||
Assert.Equal(9, rows.Count);
|
||||
foreach (var row in rows)
|
||||
{
|
||||
var code = (string)row["message"]!["code"]!;
|
||||
Assert.True(DeskVectors.SameShape(row["message"], Write(DeskRefusals.Document(code))), $"refusal {code}");
|
||||
Assert.Equal((int)row["httpStatus"]!, DeskRefusals.StatusOf(code));
|
||||
}
|
||||
|
||||
var unavailable = DeskVectors.Rows("unavailable").ToList();
|
||||
Assert.Equal(2, unavailable.Count);
|
||||
foreach (var row in unavailable)
|
||||
{
|
||||
var retry = (int?)row["message"]!["retryAfterSeconds"];
|
||||
Assert.True(DeskVectors.SameShape(row["message"], Write(DeskUnavailables.Document(retry))), (string)row["name"]!);
|
||||
Assert.Equal(DeskUnavailables.Status, (int)row["httpStatus"]!);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Every_refusal_code_in_the_schema_has_a_document()
|
||||
{
|
||||
var codes = DeskVectors.Rows("doorRefusals").Select(row => (string)row["message"]!["code"]!).ToHashSet();
|
||||
var written = typeof(DeskRefusals).GetFields().Where(f => f.IsLiteral).Select(f => (string)f.GetRawConstantValue()!).ToHashSet();
|
||||
Assert.Equal(codes, written);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Answer_results_round_trip_with_their_spelling()
|
||||
{
|
||||
var rows = DeskVectors.Rows("results").ToList();
|
||||
Assert.Equal(6, rows.Count);
|
||||
foreach (var row in rows)
|
||||
{
|
||||
var message = row["message"]!;
|
||||
var result = message.Deserialize<AnswerResult>(DeskJson.Options)!;
|
||||
Assert.True(DeskVectors.SameShape(message, Write(result)), (string)row["name"]!);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Cards_round_trip_with_their_spelling()
|
||||
{
|
||||
var rows = DeskVectors.Rows("card", "valid").ToList();
|
||||
Assert.Equal(5, rows.Count);
|
||||
foreach (var row in rows)
|
||||
{
|
||||
var message = row["message"]!;
|
||||
var card = message.Deserialize<ForkCard>(DeskJson.Options)!;
|
||||
Assert.True(DeskVectors.SameShape(message, Write(card)), (string)row["name"]!);
|
||||
}
|
||||
}
|
||||
}
|
||||
327
tests/Bifrost.Web.Tests/DeskHardeningTests.cs
Normal file
327
tests/Bifrost.Web.Tests/DeskHardeningTests.cs
Normal file
|
|
@ -0,0 +1,327 @@
|
|||
using System.Text;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Configuration;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
using Microsoft.AspNetCore.Http;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Options;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
// The rules the desk's edge keeps that a happy path never shows: whose decider list rides each call, the body cap
|
||||
// to the byte, what the Retry-After comes from, the audience's case, no-store, and what a failing port becomes.
|
||||
public sealed class DeskHardeningTests
|
||||
{
|
||||
private const string Nibu = "nibu";
|
||||
private const string Chat = "gamecult-chat";
|
||||
private const string NibuFork = "nibu:question:glow-order";
|
||||
|
||||
private static async Task<DeskWebApplicationFactory> ArrangeAsync(Dictionary<string, string?>? configuration = null)
|
||||
{
|
||||
var factory = new DeskWebApplicationFactory(configuration);
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
return factory;
|
||||
}
|
||||
|
||||
private static string Token(DeskWebApplicationFactory factory, string audience = "bifrost-desk") =>
|
||||
factory.Token(DeskWebApplicationFactory.Alice, audience, "desk.read", "desk.answer");
|
||||
|
||||
private static Task<DeskReply> SendRouteAsync(DeskWebApplicationFactory factory, string route, string mind, string token)
|
||||
{
|
||||
var fork = mind == Nibu ? NibuFork : DeskReplay.ChatFork;
|
||||
return route switch
|
||||
{
|
||||
"answer" => factory.SendAsync("POST", DeskReplay.Target("answer", mind, null), DeskReplay.AnswerBody(fork), token),
|
||||
"read" => factory.SendAsync("GET", DeskReplay.Target("read", mind, fork), null, token),
|
||||
_ => factory.SendAsync("GET", DeskReplay.Target("list", mind, null), null, token),
|
||||
};
|
||||
}
|
||||
|
||||
private static readonly string[] Routes = ["answer", "read", "list"];
|
||||
|
||||
private static string Code(DeskReply reply) => (string)JsonNode.Parse(reply.Body)!["code"]!;
|
||||
|
||||
// (a) Each Mind's list is its own: a context built from another Mind's list changes the call.
|
||||
[Fact]
|
||||
public async Task Each_call_carries_the_route_minds_own_decider_list_and_envelope()
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
Assert.NotEqual(DeskWebApplicationFactory.DecidersOf(Chat), DeskWebApplicationFactory.DecidersOf(Nibu));
|
||||
var token = Token(factory);
|
||||
|
||||
foreach (var mind in new[] { Chat, Nibu })
|
||||
{
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
factory.Door.Calls.Clear();
|
||||
var reply = await SendRouteAsync(factory, route, mind, token);
|
||||
Assert.True(reply.Status == 200, $"{mind} {route}: {reply.Status}");
|
||||
var call = Assert.Single(factory.Door.Calls);
|
||||
Assert.True(DeskWebApplicationFactory.DecidersOf(mind).SequenceEqual(call.Context.Deciders), $"{mind} {route}: deciders");
|
||||
Assert.Equal(mind, call.Context.Mind);
|
||||
Assert.Equal(DeskWebApplicationFactory.SocketOf(mind), call.Socket);
|
||||
Assert.Equal(DeskWebApplicationFactory.Alice, call.Context.Subject);
|
||||
Assert.Equal("Operator", call.Context.Authority);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// (b) The cap to the byte, at the HTTP edge, however the length is announced.
|
||||
[Theory]
|
||||
[InlineData(0)]
|
||||
[InlineData(4096)]
|
||||
[InlineData(4097)]
|
||||
[InlineData(8192)]
|
||||
public async Task A_body_of_exactly_the_cap_reaches_the_shape_judge_and_one_more_byte_does_not(int cap)
|
||||
{
|
||||
var bare = DeskReplay.AnswerBody(DeskReplay.ChatFork);
|
||||
cap = Math.Max(cap, bare.Length);
|
||||
var config = DeskWebApplicationFactory.DefaultConfiguration();
|
||||
config["Desk:MaxBodyBytes"] = cap.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
||||
using var factory = await ArrangeAsync(config);
|
||||
var token = Token(factory);
|
||||
var target = DeskReplay.Target("answer", Chat, null);
|
||||
byte[] Padded(int length) => [.. bare, .. Enumerable.Repeat((byte)' ', length - bare.Length)];
|
||||
|
||||
var modes = new (string Name, Action<HttpContext> Configure)[]
|
||||
{
|
||||
("content-length", _ => { }),
|
||||
("no content-length", http => http.Request.ContentLength = null),
|
||||
("chunked", http =>
|
||||
{
|
||||
http.Request.ContentLength = null;
|
||||
http.Request.Headers.TransferEncoding = "chunked";
|
||||
}),
|
||||
};
|
||||
foreach (var (name, configure) in modes)
|
||||
{
|
||||
factory.Door.Calls.Clear();
|
||||
var exact = await factory.SendAsync("POST", target, Padded(cap), token, configure: configure);
|
||||
Assert.True(exact.Status == 200, $"{name} exact: {exact.Status} {exact.Text}");
|
||||
Assert.Equal(cap, Assert.Single(factory.Door.Calls).Body!.Length);
|
||||
|
||||
factory.Door.Calls.Clear();
|
||||
var over = await factory.SendAsync("POST", target, Padded(cap + 1), token, configure: configure);
|
||||
Assert.True(over.Status == 400 && Code(over) == "body_invalid", $"{name} over: {over.Status} {over.Text}");
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
}
|
||||
|
||||
// A declared length over the cap is refused on the header alone, before any byte is read.
|
||||
[Fact]
|
||||
public async Task A_declared_length_over_the_cap_is_refused_before_reading()
|
||||
{
|
||||
var bare = DeskReplay.AnswerBody(DeskReplay.ChatFork);
|
||||
var config = DeskWebApplicationFactory.DefaultConfiguration();
|
||||
config["Desk:MaxBodyBytes"] = bare.Length.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
||||
using var factory = await ArrangeAsync(config);
|
||||
|
||||
var reply = await factory.SendAsync(
|
||||
"POST", DeskReplay.Target("answer", Chat, null), bare, Token(factory),
|
||||
configure: http => http.Request.ContentLength = bare.Length + 1);
|
||||
|
||||
Assert.Equal("body_invalid", Code(reply));
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
|
||||
// (c) The wait an `unavailable` names is the configured one, in the document and in the header.
|
||||
[Fact]
|
||||
public async Task Retry_after_comes_from_configuration_in_the_document_and_the_header()
|
||||
{
|
||||
var config = DeskWebApplicationFactory.DefaultConfiguration();
|
||||
config["Desk:RetryAfterSeconds"] = "7";
|
||||
using var factory = await ArrangeAsync(config);
|
||||
factory.Door.Down = true;
|
||||
var token = Token(factory);
|
||||
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
var reply = await SendRouteAsync(factory, route, Chat, token);
|
||||
Assert.True(reply.Status == 503, route);
|
||||
Assert.Equal(7, (int)JsonNode.Parse(reply.Body)!["retryAfterSeconds"]!);
|
||||
Assert.Equal("7", reply.Headers.RetryAfter.ToString());
|
||||
}
|
||||
}
|
||||
|
||||
// (d) The audience is compared ordinally.
|
||||
[Theory]
|
||||
[InlineData("BIFROST-DESK")]
|
||||
[InlineData("Bifrost-Desk")]
|
||||
[InlineData("bifrost-desk ")]
|
||||
[InlineData("bifrost-votes")]
|
||||
public async Task The_audience_is_case_sensitive(string audience)
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
var reply = await SendRouteAsync(factory, route, Chat, Token(factory, audience));
|
||||
Assert.True(reply.Status == 401 && Code(reply) == "unauthenticated", $"{route}: {reply.Status}");
|
||||
}
|
||||
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
|
||||
// (e) No desk response is cacheable: answers, refusals, unavailable and an unrecognised target alike.
|
||||
[Fact]
|
||||
public async Task Every_desk_response_is_no_store()
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
var token = Token(factory);
|
||||
var replies = new List<(string, DeskReply)>();
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
replies.Add((route + " 200", await SendRouteAsync(factory, route, Chat, token)));
|
||||
replies.Add((route + " 401", await SendRouteAsync(factory, route, Chat, "")));
|
||||
replies.Add((route + " 404", await SendRouteAsync(factory, route, "ghost", token)));
|
||||
}
|
||||
|
||||
factory.Door.Down = true;
|
||||
replies.Add(("503", await SendRouteAsync(factory, "list", Chat, token)));
|
||||
replies.Add(("unrecognised", await factory.SendAsync("GET", "/api/desk/x", null, token)));
|
||||
|
||||
foreach (var (label, reply) in replies)
|
||||
{
|
||||
Assert.True(reply.Headers.CacheControl.ToString() == "no-store", $"{label}: '{reply.Headers.CacheControl}'");
|
||||
}
|
||||
|
||||
Assert.Equal(200, replies[0].Item2.Status);
|
||||
Assert.Equal(503, replies[^2].Item2.Status);
|
||||
}
|
||||
|
||||
// (f) A cancelled request is not `unavailable`: the exception goes on to the host.
|
||||
[Fact]
|
||||
public async Task A_cancelled_request_is_not_called_unavailable()
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
using var cts = new CancellationTokenSource();
|
||||
factory.Door.AnswerScript = (_, _, _) =>
|
||||
{
|
||||
cts.Cancel();
|
||||
throw new IOException("the client went away");
|
||||
};
|
||||
|
||||
var reply = await factory.SendAsync(
|
||||
"POST", DeskReplay.Target("answer", Chat, null), DeskReplay.AnswerBody(DeskReplay.ChatFork), Token(factory),
|
||||
configure: http => http.RequestAborted = cts.Token);
|
||||
|
||||
// The host's exception handling answers; the desk does not claim the door was merely unavailable.
|
||||
Assert.NotEqual(503, reply.Status);
|
||||
Assert.DoesNotContain("unavailable", reply.Text);
|
||||
}
|
||||
|
||||
// (f) A stale_fork needs the current card; a card read that finds nothing, for any code, is `unavailable`.
|
||||
[Theory]
|
||||
[InlineData("fork_unknown")]
|
||||
[InlineData("request_invalid")]
|
||||
[InlineData("made_up")]
|
||||
public async Task A_stale_fork_whose_card_read_finds_nothing_is_unavailable_never_a_stale_fork_without_a_card(string code)
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
var stale = new AnswerResult(
|
||||
DeskSchemas.AnswerResult,
|
||||
new DeskAnswerDocument(
|
||||
DeskSchemas.DeskAnswer, "n1", DeskReplay.ChatFork, "Refused", null, null, "stale_fork", "oldhash", "no", null,
|
||||
"2026-11-12T19:02:00Z", "2026-11-12T19:02:05Z", false, DeskWebApplicationFactory.Alice, "Operator",
|
||||
"00000001-0000-4000-8000-000000000001"),
|
||||
null,
|
||||
null);
|
||||
factory.Door.AnswerScript = (_, _, _) => new DeskAnswerOutcome.Answered(stale);
|
||||
factory.Door.ReadScript = (_, _) => new DeskReadOutcome.NotFound(code);
|
||||
|
||||
var reply = await SendRouteAsync(factory, "answer", Chat, Token(factory));
|
||||
|
||||
Assert.Equal(503, reply.Status);
|
||||
Assert.Equal("unavailable", Code(reply));
|
||||
Assert.Null(JsonNode.Parse(reply.Body)!["card"]);
|
||||
Assert.Contains(factory.Door.Calls, c => c.Kind == "read");
|
||||
}
|
||||
|
||||
// (h) A port that fails is `unavailable`, never a 500 and never a pass.
|
||||
[Fact]
|
||||
public async Task A_throwing_credential_port_is_unavailable_and_opens_nothing()
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
factory.Credential.Throws = true;
|
||||
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
var reply = await SendRouteAsync(factory, route, Chat, Token(factory));
|
||||
Assert.True(reply.Status == 503 && Code(reply) == "unavailable", $"{route}: {reply.Status}");
|
||||
}
|
||||
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_throwing_account_lookup_is_unavailable_and_opens_nothing()
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
// The request's database context is gone by the time the desk looks the account up (the database failed).
|
||||
factory.Credential.OnAuthenticate = http => http.RequestServices.GetRequiredService<Bifrost.Web.Data.BifrostDbContext>().Dispose();
|
||||
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
var reply = await SendRouteAsync(factory, route, Chat, Token(factory));
|
||||
Assert.True(reply.Status == 503 && Code(reply) == "unavailable", $"{route}: {reply.Status}");
|
||||
}
|
||||
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
|
||||
// The runtime guard on the decider list (the startup validator is the first layer; this is the second).
|
||||
private static string Id(int n) => new Guid(n, 0, 0, new byte[8]).ToString("D");
|
||||
|
||||
private static void SetDeciders(DeskWebApplicationFactory factory, string mind, IEnumerable<string> ids)
|
||||
{
|
||||
var list = factory.Services.GetRequiredService<IOptions<DeskOptions>>().Value.Minds.Single(m => m.Id == mind).Deciders;
|
||||
list.Clear();
|
||||
list.AddRange(ids);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task The_door_is_called_with_64_deciders()
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
var ids = Enumerable.Range(1, 64).Select(Id).ToList();
|
||||
SetDeciders(factory, Chat, ids);
|
||||
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
factory.Door.Calls.Clear();
|
||||
var reply = await SendRouteAsync(factory, route, Chat, Token(factory));
|
||||
Assert.True(reply.Status == 200, route);
|
||||
Assert.Equal(ids, Assert.Single(factory.Door.Calls).Context.Deciders);
|
||||
}
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("65")]
|
||||
[InlineData("0")]
|
||||
[InlineData("duplicate")]
|
||||
public async Task A_decider_list_out_of_bounds_is_unavailable_without_a_door_call(string fault)
|
||||
{
|
||||
using var factory = await ArrangeAsync();
|
||||
var ids = fault switch
|
||||
{
|
||||
"65" => Enumerable.Range(1, 65).Select(Id).ToList(),
|
||||
"0" => [],
|
||||
_ => [Id(1), Id(2), Id(1)],
|
||||
};
|
||||
SetDeciders(factory, Chat, ids);
|
||||
|
||||
foreach (var route in Routes)
|
||||
{
|
||||
var reply = await SendRouteAsync(factory, route, Chat, Token(factory));
|
||||
Assert.True(reply.Status == 503 && Code(reply) == "unavailable", $"{route}: {reply.Status}");
|
||||
}
|
||||
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
|
||||
// Only that Mind's list is at fault: the other Mind still answers.
|
||||
var other = await SendRouteAsync(factory, "list", Nibu, Token(factory));
|
||||
Assert.Equal(200, other.Status);
|
||||
}
|
||||
}
|
||||
91
tests/Bifrost.Web.Tests/DeskMindRouteTests.cs
Normal file
91
tests/Bifrost.Web.Tests/DeskMindRouteTests.cs
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskMindRouteTests
|
||||
{
|
||||
private static async Task<(DeskReply Reply, DeskWebApplicationFactory Factory)> RunAsync(JsonObject row)
|
||||
{
|
||||
var factory = new DeskWebApplicationFactory();
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
var token = await DeskReplay.TokenAsync(factory, row["token"]);
|
||||
var route = (string)row["route"]!;
|
||||
var forkId = (string?)row["fork_id"];
|
||||
var reply = await factory.SendAsync(
|
||||
route == "answer" ? "POST" : "GET",
|
||||
DeskReplay.Target(route, (string)row["mind"]!, forkId),
|
||||
route == "answer" ? DeskReplay.AnswerBody(forkId!) : null,
|
||||
token);
|
||||
return (reply, factory);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Vector_route_cases()
|
||||
{
|
||||
var cases = DeskVectors.Rows("transport", "mindRoutes", "cases").ToList();
|
||||
Assert.Equal(57, cases.Count);
|
||||
|
||||
foreach (var row in cases)
|
||||
{
|
||||
var name = (string)row["name"]!;
|
||||
var (reply, factory) = await RunAsync(row);
|
||||
using (factory)
|
||||
{
|
||||
Assert.True((int)row["httpStatus"]! == reply.Status, $"{name}: {reply.Status} {reply.Text}");
|
||||
var expect = (string)row["expect"]!;
|
||||
if (expect != "ok")
|
||||
{
|
||||
Assert.True(
|
||||
DeskVectors.SameShape(JsonNode.Parse(reply.Body), JsonNode.Parse(JsonSerializer.Serialize(DeskRefusals.Document(expect), DeskJson.Options))),
|
||||
name);
|
||||
}
|
||||
|
||||
var opened = (string?)row["opened"];
|
||||
if (opened is null)
|
||||
{
|
||||
Assert.True(factory.Door.Calls.Count == 0, $"{name}: opened {factory.Door.Calls.FirstOrDefault()?.Socket}");
|
||||
}
|
||||
else
|
||||
{
|
||||
var call = Assert.Single(factory.Door.Calls);
|
||||
Assert.True(call.Socket.EndsWith("/" + opened, StringComparison.Ordinal), $"{name}: {call.Socket}");
|
||||
}
|
||||
|
||||
var storedIn = (string?)row["stored_in"];
|
||||
if (storedIn is null)
|
||||
{
|
||||
Assert.Empty(factory.Door.StoredIn);
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal([DeskWebApplicationFactory.SocketOf(storedIn)], factory.Door.StoredIn);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Same_response_pairs_are_byte_equal()
|
||||
{
|
||||
var cases = DeskVectors.Rows("transport", "mindRoutes", "cases").ToDictionary(r => (string)r["name"]!);
|
||||
var pairs = DeskVectors.Array("transport", "mindRoutes", "sameResponse");
|
||||
Assert.Equal(4, pairs.Count);
|
||||
|
||||
foreach (var pair in pairs)
|
||||
{
|
||||
var first = cases[(string)pair![0]!];
|
||||
var second = cases[(string)pair[1]!];
|
||||
var (a, fa) = await RunAsync(first);
|
||||
var (b, fb) = await RunAsync(second);
|
||||
using (fa)
|
||||
using (fb)
|
||||
{
|
||||
Assert.Equal(a.Status, b.Status);
|
||||
Assert.Equal(a.Body, b.Body);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
125
tests/Bifrost.Web.Tests/DeskMindRoutesTests.cs
Normal file
125
tests/Bifrost.Web.Tests/DeskMindRoutesTests.cs
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
using Bifrost.Web.Configuration;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskMindRoutesTests
|
||||
{
|
||||
private static DeskMindRoutes Routes()
|
||||
{
|
||||
var minds = DeskVectors.Root["transport"]!["mindRoutes"]!["minds"]!.AsObject();
|
||||
return new DeskMindRoutes(minds.Select(m => new DeskMindOptions { Id = m.Key, Socket = "/run/huginn/" + (string)m.Value! }));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Every_vector_segment_resolves_or_misses()
|
||||
{
|
||||
var routes = Routes();
|
||||
var cases = DeskVectors.Rows("transport", "mindRoutes", "cases").ToList();
|
||||
Assert.Equal(57, cases.Count);
|
||||
|
||||
foreach (var row in cases)
|
||||
{
|
||||
var mind = (string)row["mind"]!;
|
||||
var opened = (string?)row["opened"];
|
||||
var resolved = routes.Resolve(mind);
|
||||
|
||||
// A route that opens a socket resolves to the Mind whose socket it is; every other route is a miss.
|
||||
// Auth-refused cases never reach the lookup, so only the cases that reach it are judged here.
|
||||
var expect = (string)row["expect"]!;
|
||||
if (expect is not ("ok" or "fork_unknown" or "unavailable"))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (opened is null)
|
||||
{
|
||||
Assert.True(resolved is null, $"{row["name"]}: '{Short(mind)}' resolved to '{resolved?.Id}'");
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.True(resolved is not null, $"{row["name"]}: '{Short(mind)}' missed");
|
||||
Assert.EndsWith(opened, resolved!.Socket, StringComparison.Ordinal);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Segments_that_do_not_name_a_configured_mind_miss()
|
||||
{
|
||||
var routes = Routes();
|
||||
foreach (var mind in new[]
|
||||
{
|
||||
"ghost", ".", "..", "../x", "a/b", "a%2fb", "%2e%2e%2fx", "eureka%00", "nibu%20", "nibu ", " nibu",
|
||||
"%ff", "%c3%28", "%", "%6", "%zz", "nibu%", "%256eibu", "", new string('a', 4096), "nïbu",
|
||||
})
|
||||
{
|
||||
Assert.Null(routes.Resolve(mind));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Percent_encoded_configured_ids_are_decoded_once()
|
||||
{
|
||||
var routes = Routes();
|
||||
|
||||
Assert.Equal("nibu", routes.Resolve("%6eibu")!.Id);
|
||||
Assert.Equal("nibu", routes.Resolve("%6Eibu")!.Id);
|
||||
Assert.Equal("gamecult-chat", routes.Resolve("gamecult%2Dchat")!.Id);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Other_case_misses_despite_config_case_insensitivity()
|
||||
{
|
||||
var routes = Routes();
|
||||
|
||||
Assert.Null(routes.Resolve("GAMECULT-CHAT"));
|
||||
Assert.Null(routes.Resolve("Nibu"));
|
||||
Assert.Null(routes.Resolve("gamecult-chat%20"));
|
||||
Assert.NotNull(routes.Resolve("gamecult-chat"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Double_encoded_misses()
|
||||
{
|
||||
var routes = Routes();
|
||||
|
||||
Assert.Null(routes.Resolve("%256eibu"));
|
||||
Assert.Null(routes.Resolve("gamecult%252Dchat"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Configured_ids_that_differ_only_by_case_stay_distinct()
|
||||
{
|
||||
var routes = new DeskMindRoutes([
|
||||
new DeskMindOptions { Id = "a", Socket = "/s/a" },
|
||||
new DeskMindOptions { Id = "A", Socket = "/s/A" },
|
||||
]);
|
||||
|
||||
Assert.Equal("/s/a", routes.Resolve("a")!.Socket);
|
||||
Assert.Equal("/s/A", routes.Resolve("A")!.Socket);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_decoding_failure_is_a_miss_even_when_the_failure_spells_a_configured_id()
|
||||
{
|
||||
var replacement = char.ConvertFromUtf32(0xFFFD);
|
||||
var e = char.ConvertFromUtf32(0xE9);
|
||||
var routes = new DeskMindRoutes([
|
||||
new DeskMindOptions { Id = replacement, Socket = "/s/replacement" },
|
||||
new DeskMindOptions { Id = e, Socket = "/s/e-acute" },
|
||||
new DeskMindOptions { Id = "a%zz", Socket = "/s/bad-escape" },
|
||||
new DeskMindOptions { Id = "100%", Socket = "/s/trailing" },
|
||||
]);
|
||||
|
||||
Assert.Null(routes.Resolve("%ff")); // not UTF-8, not U+FFFD
|
||||
Assert.Null(routes.Resolve(char.ConvertFromUtf32(0xC3) + char.ConvertFromUtf32(0xA9))); // UTF-8 bytes as raw chars
|
||||
Assert.Null(routes.Resolve("a%zz"));
|
||||
Assert.Null(routes.Resolve("100%"));
|
||||
Assert.Equal("/s/replacement", routes.Resolve("%ef%bf%bd")!.Socket); // the real encoding still resolves
|
||||
Assert.Equal("/s/e-acute", routes.Resolve("%c3%a9")!.Socket);
|
||||
}
|
||||
|
||||
private static string Short(string value) => value.Length > 40 ? value[..40] + "..." : value;
|
||||
}
|
||||
234
tests/Bifrost.Web.Tests/DeskOptionsTests.cs
Normal file
234
tests/Bifrost.Web.Tests/DeskOptionsTests.cs
Normal file
|
|
@ -0,0 +1,234 @@
|
|||
using Microsoft.Extensions.Configuration;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
using Bifrost.Web.Configuration;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Features.Shared;
|
||||
using Microsoft.Extensions.Options;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskOptionsTests
|
||||
{
|
||||
private const string Alice = "e0d1c2b3-a495-4687-8879-6a5b4c3d2e1f";
|
||||
private const string Bob = "00000000-0000-4000-8000-000000000002";
|
||||
|
||||
private static Dictionary<string, string?> Good() => new()
|
||||
{
|
||||
["Desk:AllowedOrigin"] = "https://chat.gamecult.org",
|
||||
["Desk:Minds:0:Id"] = "gamecult-chat",
|
||||
["Desk:Minds:0:Socket"] = "/run/huginn/huginn-gamecult-chat.sock",
|
||||
["Desk:Minds:0:Deciders:0"] = Alice,
|
||||
["Desk:Minds:1:Id"] = "nibu",
|
||||
["Desk:Minds:1:Socket"] = "/run/huginn/huginn-nibu.sock",
|
||||
["Desk:Minds:1:Deciders:0"] = Bob,
|
||||
["Desk:Attribution:Operator"] = Alice,
|
||||
["Desk:Attribution:Stewards:0"] = Bob,
|
||||
};
|
||||
|
||||
private static DeskOptions Bind(Dictionary<string, string?> values)
|
||||
{
|
||||
var options = new DeskOptions();
|
||||
new ConfigurationBuilder().AddInMemoryCollection(values).Build().GetSection(DeskOptions.SectionName).Bind(options);
|
||||
return options;
|
||||
}
|
||||
|
||||
private static void Validate(Dictionary<string, string?> values, string environment = "Testing")
|
||||
{
|
||||
var configuration = new ConfigurationBuilder().AddInMemoryCollection(values).Build();
|
||||
new StartupConfigurationValidator(
|
||||
configuration,
|
||||
new StubEnvironment(environment),
|
||||
Options.Create(new GitHubOAuthOptions()),
|
||||
Options.Create(new GitHubAppOptions()),
|
||||
Options.Create(new HeimdallOptions()),
|
||||
Options.Create(new StripeOptions()),
|
||||
Options.Create(new BifrostHostOptions()),
|
||||
Options.Create(new ConceptVoteOptions()),
|
||||
Options.Create(Bind(values))).Validate();
|
||||
}
|
||||
|
||||
private static void Refused(Dictionary<string, string?> values, string expectedFragment)
|
||||
{
|
||||
var failure = Assert.Throws<InvalidOperationException>(() => Validate(values));
|
||||
Assert.Contains(expectedFragment, failure.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_good_desk_configuration_binds_by_position_and_passes()
|
||||
{
|
||||
var options = Bind(Good());
|
||||
|
||||
Assert.Equal(["gamecult-chat", "nibu"], options.Minds.Select(m => m.Id));
|
||||
Assert.Equal([Alice], options.Minds[0].Deciders);
|
||||
Assert.Equal([Bob], options.Minds[1].Deciders);
|
||||
Validate(Good());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void No_desk_section_is_not_configured_and_passes()
|
||||
{
|
||||
Assert.False(Bind([]).IsConfigured);
|
||||
Validate([]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Mind_ids_keep_the_case_the_configuration_gave_them()
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:0:Id"] = "GameCult-Chat";
|
||||
|
||||
Assert.Equal("GameCult-Chat", Bind(values).Minds[0].Id);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Startup_refuses_duplicate_ids() => Refused(Dup(), "Desk:Minds:1:Id repeats");
|
||||
|
||||
private static Dictionary<string, string?> Dup()
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:1:Id"] = "gamecult-chat";
|
||||
return values;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Startup_refuses_a_blank_id()
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:1:Id"] = " ";
|
||||
|
||||
Refused(values, "Desk:Minds:1:Id must not be blank");
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("huginn.sock")]
|
||||
[InlineData("run/huginn.sock")]
|
||||
[InlineData("")]
|
||||
public void Startup_refuses_relative_socket(string socket)
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:1:Socket"] = socket;
|
||||
|
||||
Refused(values, "Desk:Minds:1:Socket must be an absolute path");
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("E0D1C2B3-A495-4687-8879-6A5B4C3D2E1F")]
|
||||
[InlineData("e0d1c2b3a495468788796a5b4c3d2e1f")]
|
||||
[InlineData("{e0d1c2b3-a495-4687-8879-6a5b4c3d2e1f}")]
|
||||
[InlineData("not-a-guid")]
|
||||
[InlineData("")]
|
||||
public void Startup_refuses_bad_decider_id(string decider)
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:0:Deciders:1"] = decider;
|
||||
|
||||
Refused(values, "Desk:Minds:0:Deciders entries must be lowercase D-format");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Startup_refuses_a_repeated_decider()
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:0:Deciders:1"] = Alice;
|
||||
|
||||
Refused(values, "Desk:Minds:0:Deciders repeats");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Startup_refuses_operator_in_stewards()
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Attribution:Stewards:1"] = Alice;
|
||||
|
||||
Refused(values, "must not also be a steward");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Startup_refuses_bad_or_repeated_attribution_ids()
|
||||
{
|
||||
var bad = Good();
|
||||
bad["Desk:Attribution:Operator"] = "ALICE";
|
||||
Refused(bad, "Desk:Attribution:Operator must be a lowercase");
|
||||
|
||||
var badSteward = Good();
|
||||
badSteward["Desk:Attribution:Stewards:1"] = "E0D1C2B3-A495-4687-8879-6A5B4C3D2E1F";
|
||||
Refused(badSteward, "Desk:Attribution:Stewards entries must be lowercase");
|
||||
|
||||
var repeated = Good();
|
||||
repeated["Desk:Attribution:Stewards:1"] = Bob;
|
||||
Refused(repeated, "Desk:Attribution:Stewards repeats");
|
||||
}
|
||||
|
||||
private static string Id(int n) => new Guid(n, 0, 0, new byte[8]).ToString("D");
|
||||
|
||||
private static Dictionary<string, string?> WithDeciders(int count)
|
||||
{
|
||||
var values = Good();
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
values[$"Desk:Minds:0:Deciders:{i}"] = Id(i + 1);
|
||||
}
|
||||
|
||||
if (count == 0)
|
||||
{
|
||||
values.Remove("Desk:Minds:0:Deciders:0");
|
||||
}
|
||||
|
||||
return values;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Startup_takes_one_to_64_deciders_per_mind()
|
||||
{
|
||||
Validate(WithDeciders(1));
|
||||
Validate(WithDeciders(64));
|
||||
Refused(WithDeciders(65), "Desk:Minds:0:Deciders must hold 1 to 64");
|
||||
Refused(WithDeciders(0), "Desk:Minds:0:Deciders must hold 1 to 64");
|
||||
|
||||
// The bound is per Mind: the second Mind is judged on its own list.
|
||||
var second = Good();
|
||||
second.Remove("Desk:Minds:1:Deciders:0");
|
||||
Refused(second, "Desk:Minds:1:Deciders must hold 1 to 64");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Startup_refuses_two_minds_sharing_one_socket()
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:1:Socket"] = values["Desk:Minds:0:Socket"];
|
||||
|
||||
Refused(values, "Desk:Minds:1:Socket repeats an earlier Mind's socket");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Desk_failures_are_reported_in_production_too_and_alongside_each_other()
|
||||
{
|
||||
var values = Good();
|
||||
values["Desk:Minds:1:Socket"] = "relative";
|
||||
values["Desk:Attribution:Stewards:1"] = Alice;
|
||||
|
||||
var failure = Assert.Throws<InvalidOperationException>(() => Validate(values, "Production"));
|
||||
Assert.Contains("Desk:Minds:1:Socket", failure.Message);
|
||||
Assert.Contains("must not also be a steward", failure.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Attribution_is_operator_steward_member()
|
||||
{
|
||||
var attribution = Bind(Good()).Attribution;
|
||||
|
||||
Assert.Equal("Operator", attribution.AuthorityOf(Alice));
|
||||
Assert.Equal("Steward", attribution.AuthorityOf(Bob));
|
||||
Assert.Equal("Member", attribution.AuthorityOf("00000000-0000-4000-8000-000000000003"));
|
||||
Assert.Equal("Member", attribution.AuthorityOf(Alice.ToUpperInvariant()));
|
||||
Assert.Equal("Member", new DeskAttributionOptions().AuthorityOf(string.Empty));
|
||||
}
|
||||
|
||||
private sealed class StubEnvironment(string name) : IHostEnvironment
|
||||
{
|
||||
public string EnvironmentName { get; set; } = name;
|
||||
public string ApplicationName { get; set; } = "Bifrost.Web";
|
||||
public string ContentRootPath { get; set; } = string.Empty;
|
||||
public Microsoft.Extensions.FileProviders.IFileProvider ContentRootFileProvider { get; set; } = null!;
|
||||
}
|
||||
}
|
||||
354
tests/Bifrost.Web.Tests/DeskReadTests.cs
Normal file
354
tests/Bifrost.Web.Tests/DeskReadTests.cs
Normal file
|
|
@ -0,0 +1,354 @@
|
|||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskReadTests
|
||||
{
|
||||
private static string ReadToken(DeskWebApplicationFactory f) =>
|
||||
f.Token(DeskWebApplicationFactory.Alice, "bifrost-desk", "desk.read");
|
||||
|
||||
private static Uri Unused => new("http://unused");
|
||||
|
||||
// A list_request invalid row names the query that cannot express it; the others are the shapes a query cannot hold.
|
||||
private static readonly Dictionary<string, string> InvalidListQueries = new()
|
||||
{
|
||||
["limit_51"] = "?limit=51",
|
||||
["limit_negative"] = "?limit=-1",
|
||||
["status_all"] = "?status=all",
|
||||
["cursor_malformed"] = "?cursor=next",
|
||||
["cursor_zero"] = "?cursor=c0",
|
||||
["unknown_key"] = "?sort=oldest",
|
||||
};
|
||||
|
||||
[Fact]
|
||||
public async Task List_and_read_request_invalid_vectors()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
var token = ReadToken(factory);
|
||||
|
||||
var invalid = DeskVectors.Rows("transport", "listRequest", "invalid").Select(r => (string)r["name"]!).ToList();
|
||||
foreach (var name in invalid.Where(n => n != "mind_empty"))
|
||||
{
|
||||
var reply = await factory.SendAsync("GET", "/api/desk/gamecult-chat/forks" + InvalidListQueries[name], null, token);
|
||||
Assert.True(reply.Status == 400, $"{name}: {reply.Status}");
|
||||
Assert.Equal("request_invalid", (string?)JsonNode.Parse(reply.Body)!["code"]);
|
||||
}
|
||||
|
||||
// Also: repeated key, bad escape, query on a read, empty fork id.
|
||||
foreach (var target in new[]
|
||||
{
|
||||
"/api/desk/gamecult-chat/forks?limit=1&limit=2", "/api/desk/gamecult-chat/forks?limit=%zz", "/api/desk/gamecult-chat/forks?limit=",
|
||||
"/api/desk/gamecult-chat/forks?limit=+1", "/api/desk/gamecult-chat/forks?limit=1.0",
|
||||
"/api/desk/gamecult-chat/forks/gamecult-chat%3Aquestion%3Aq1?x=1", "/api/desk/gamecult-chat/forks/", "/api/desk/gamecult-chat/forks/%ff",
|
||||
})
|
||||
{
|
||||
var reply = await factory.SendAsync("GET", target, null, token);
|
||||
Assert.True(reply.Status == 400, $"{target}: {reply.Status}");
|
||||
}
|
||||
|
||||
// The invalid request is judged before the Mind: an unknown Mind with a bad query is the query's refusal.
|
||||
var order = await factory.SendAsync("GET", "/api/desk/ghost/forks?limit=99", null, token);
|
||||
Assert.Equal("request_invalid", (string?)JsonNode.Parse(order.Body)!["code"]);
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Valid_list_queries_reach_the_door_as_typed_requests()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
foreach (var row in DeskVectors.Rows("transport", "listRequest", "valid"))
|
||||
{
|
||||
var m = row["message"]!;
|
||||
var query = $"?status={(string?)m["status"]}&cursor={(string?)m["cursor"]}&limit={(int)m["limit"]!}";
|
||||
var reply = await factory.SendAsync("GET", "/api/desk/gamecult-chat/forks" + query, null, ReadToken(factory));
|
||||
Assert.Equal(200, reply.Status);
|
||||
var call = factory.Door.Calls[^1];
|
||||
Assert.Equal(new DeskListRequest("gamecult-chat", (string?)m["status"], (string?)m["cursor"], (int)m["limit"]!), call.List);
|
||||
}
|
||||
|
||||
var bare = await factory.SendAsync("GET", "/api/desk/nibu/forks", null, ReadToken(factory));
|
||||
Assert.Equal(new DeskListRequest("nibu", null, null, 50), factory.Door.Calls[^1].List);
|
||||
Assert.Equal(200, bare.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task List_scenarios_pass_through()
|
||||
{
|
||||
var steps = 0;
|
||||
foreach (var scenario in DeskVectors.Rows("transport", "listScenarios"))
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
foreach (var step in scenario["steps"]!.AsArray().Select(s => s!.AsObject()))
|
||||
{
|
||||
var request = step["request"]!;
|
||||
var response = step["response"]!.AsObject();
|
||||
var list = response.Deserialize<ForkList>(DeskJson.Options)!;
|
||||
factory.Door.ListScript = (_, _) => new DeskListOutcome.Listed(list);
|
||||
var query = $"?status={(string?)request["status"]}&cursor={(string?)request["cursor"]}&limit={(int)request["limit"]!}";
|
||||
|
||||
var reply = await factory.SendAsync("GET", $"/api/desk/{(string)request["mind"]!}/forks" + query, null, ReadToken(factory));
|
||||
|
||||
Assert.Equal(200, reply.Status);
|
||||
Assert.True(DeskVectors.SameShape(JsonNode.Parse(reply.Body), response), (string)scenario["name"]!);
|
||||
steps++;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(7, steps);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Read_returns_the_entry_unchanged_and_an_unknown_fork_is_refused()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
var ok = await factory.SendAsync("GET", DeskReplay.Target("read", "gamecult-chat", DeskReplay.ChatFork), null, ReadToken(factory));
|
||||
var entry = JsonSerializer.SerializeToNode(DeskReplay.Entry(DeskReplay.Card(DeskReplay.ChatFork)), DeskJson.Options);
|
||||
var missing = await factory.SendAsync("GET", DeskReplay.Target("read", "gamecult-chat", "gamecult-chat:question:ghost"), null, ReadToken(factory));
|
||||
|
||||
Assert.Equal(200, ok.Status);
|
||||
Assert.True(DeskVectors.SameShape(JsonNode.Parse(ok.Body), entry));
|
||||
Assert.Equal(DeskReplay.ChatFork, Assert.IsType<string>(factory.Door.Calls[0].ForkId));
|
||||
Assert.Equal(404, missing.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_fork_too_large_for_a_page_is_a_422_that_names_the_fork_and_the_cursor_to_continue_with()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
factory.Door.ListScript = (_, _) => new DeskListOutcome.ForkTooLarge("nibu:question:huge", 7);
|
||||
var reply = await factory.SendAsync("GET", "/api/desk/nibu/forks", null, ReadToken(factory));
|
||||
var doc = JsonNode.Parse(reply.Body)!;
|
||||
Assert.Equal(422, reply.Status);
|
||||
Assert.Equal("fork_too_large", (string?)doc["code"]);
|
||||
var error = (string)doc["error"]!;
|
||||
Assert.Contains("nibu:question:huge", error);
|
||||
Assert.Contains("order 7", error);
|
||||
Assert.Contains("c7", error);
|
||||
|
||||
// At order 0 there is no cursor to continue with: the list has reached its end.
|
||||
factory.Door.ListScript = (_, _) => new DeskListOutcome.ForkTooLarge("nibu:question:first", 0);
|
||||
var end = await factory.SendAsync("GET", "/api/desk/nibu/forks", null, ReadToken(factory));
|
||||
var endError = (string)JsonNode.Parse(end.Body)!["error"]!;
|
||||
Assert.Equal(422, end.Status);
|
||||
Assert.Contains("nibu:question:first", endError);
|
||||
Assert.Contains("order 0", endError);
|
||||
Assert.DoesNotContain("cursor c0", endError);
|
||||
Assert.Contains("end", endError);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task fork_too_large_is_list_only_elsewhere_the_door_saying_it_is_unavailable()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
factory.Door.ReadScript = (_, _) => new DeskReadOutcome.NotFound("fork_too_large");
|
||||
factory.Door.ListScript = (_, _) => new DeskListOutcome.NotListed("fork_too_large");
|
||||
foreach (var target in new[] { "/api/desk/nibu/forks", DeskReplay.Target("read", "nibu", "nibu:question:glow-order") })
|
||||
{
|
||||
var reply = await factory.SendAsync("GET", target, null, ReadToken(factory));
|
||||
Assert.Equal(503, reply.Status);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_short_page_with_a_cursor_below_its_last_entry_passes_through_unchanged()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
factory.Door.ListScript = (_, r) => new DeskListOutcome.Listed(new ForkList("gamecult.fork.list.v0", r.Mind, "s1", 3, 0, [], "c2"));
|
||||
|
||||
var reply = await factory.SendAsync("GET", "/api/desk/nibu/forks?limit=10", null, ReadToken(factory));
|
||||
|
||||
Assert.Equal(200, reply.Status);
|
||||
Assert.Equal("c2", (string?)JsonNode.Parse(reply.Body)!["next_cursor"]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_door_that_refuses_a_read_or_list_for_a_body_field_such_as_authority_is_request_invalid_not_unavailable()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
foreach (var code in new[] { "body_forbidden_field", "body_unknown_field", "body_invalid" })
|
||||
{
|
||||
factory.Door.ReadScript = (_, _) => new DeskReadOutcome.NotFound(code);
|
||||
factory.Door.ListScript = (_, _) => new DeskListOutcome.NotListed(code);
|
||||
foreach (var target in new[] { "/api/desk/nibu/forks", DeskReplay.Target("read", "nibu", "nibu:question:glow-order") })
|
||||
{
|
||||
var reply = await factory.SendAsync("GET", target, null, ReadToken(factory));
|
||||
Assert.Equal(400, reply.Status);
|
||||
Assert.Equal("request_invalid", (string?)JsonNode.Parse(reply.Body)!["code"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task request_id_conflict_is_the_answers_alone_on_read_and_list_it_is_a_door_fault()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
factory.Door.ReadScript = (_, _) => new DeskReadOutcome.NotFound(DeskRefusals.RequestIdConflict);
|
||||
factory.Door.ListScript = (_, _) => new DeskListOutcome.NotListed(DeskRefusals.RequestIdConflict);
|
||||
foreach (var target in new[] { "/api/desk/nibu/forks", DeskReplay.Target("read", "nibu", "nibu:question:glow-order") })
|
||||
{
|
||||
var reply = await factory.SendAsync("GET", target, null, ReadToken(factory));
|
||||
Assert.Equal(503, reply.Status);
|
||||
Assert.Equal("unavailable", (string?)JsonNode.Parse(reply.Body)!["code"]);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Door_failure_on_list_and_read_is_unavailable()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
factory.Door.Down = true;
|
||||
|
||||
foreach (var target in new[] { "/api/desk/nibu/forks", DeskReplay.Target("read", "nibu", "nibu:question:glow-order") })
|
||||
{
|
||||
var reply = await factory.SendAsync("GET", target, null, ReadToken(factory));
|
||||
Assert.Equal(503, reply.Status);
|
||||
Assert.Equal(30, (int?)JsonNode.Parse(reply.Body)!["retryAfterSeconds"]);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Every_door_call_carries_the_configured_deciders_and_nothing_in_the_request_can_change_them()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
var hostile = "deciders=" + DeskWebApplicationFactory.Member;
|
||||
Action<Microsoft.AspNetCore.Http.HttpContext> headers = http =>
|
||||
{
|
||||
http.Request.Headers["X-Deciders"] = DeskWebApplicationFactory.Member;
|
||||
http.Request.Headers["Deciders"] = DeskWebApplicationFactory.Member;
|
||||
};
|
||||
var read = ReadToken(factory);
|
||||
var answer = factory.Token(DeskWebApplicationFactory.Alice, "bifrost-desk", "desk.answer");
|
||||
|
||||
await factory.SendAsync("GET", "/api/desk/nibu/forks", null, read, configure: headers);
|
||||
var hostileList = await factory.SendAsync("GET", "/api/desk/nibu/forks?" + hostile, null, read, configure: headers);
|
||||
Assert.Equal(400, hostileList.Status);
|
||||
await factory.SendAsync("GET", DeskReplay.Target("read", "nibu", "nibu:question:glow-order"), null, read, configure: headers);
|
||||
await factory.SendAsync("POST", DeskReplay.Target("answer", "nibu", null) + "?" + hostile, DeskReplay.AnswerBody("nibu:question:glow-order"), answer, configure: headers);
|
||||
// A body naming deciders never reaches the door.
|
||||
var body = JsonNode.Parse(DeskReplay.AnswerBody("nibu:question:glow-order"))!.AsObject();
|
||||
body["deciders"] = new JsonArray(DeskWebApplicationFactory.Member);
|
||||
var named = await factory.SendAsync("POST", DeskReplay.Target("answer", "nibu", null), DeskVectors.Bytes(body), answer);
|
||||
|
||||
Assert.Equal("body_unknown_field", (string?)JsonNode.Parse(named.Body)!["code"]);
|
||||
Assert.Equal(["list", "read", "answer"], factory.Door.Calls.Select(c => c.Kind).ToArray());
|
||||
Assert.All(factory.Door.Calls, c => Assert.Equal(DeskWebApplicationFactory.DecidersOf("nibu"), c.Context.Deciders));
|
||||
}
|
||||
private const string Secret = "the decider's own words";
|
||||
|
||||
private static DeskAnswerDocument Doc(string id, string outcome, string? of, string? retracts, string? note) => new(
|
||||
DeskSchemas.DeskAnswer, id, DeskReplay.ChatFork, outcome, of, retracts, null, "h", note == null ? null : "a", note,
|
||||
"2026-11-12T19:00:00Z", "2026-11-12T19:00:01Z", false, DeskWebApplicationFactory.Alice, "Steward", "r-" + id);
|
||||
|
||||
// Counted, Revision, Retraction and Refused documents, every one carrying the decider's note.
|
||||
private static ForkEntry NotedEntry()
|
||||
{
|
||||
var entry = DeskReplay.Entry(DeskReplay.Card(DeskReplay.ChatFork));
|
||||
DeskAnswerDocument[] answers =
|
||||
[
|
||||
Doc("n1", "Counted", null, null, Secret),
|
||||
Doc("n2", "Revision", "n1", null, Secret + " 2"),
|
||||
Doc("n3", "Retraction", null, "n2", Secret + " 3"),
|
||||
Doc("n4", "Refused", null, null, Secret + " 4"),
|
||||
];
|
||||
return entry with { Record = entry.Record with { CountedAnswerId = "n1", Answers = answers } };
|
||||
}
|
||||
|
||||
private static bool AnyNote(JsonNode? node) => node switch
|
||||
{
|
||||
JsonObject o => o.Any(kv => (kv.Key == "note" && kv.Value is not null) || AnyNote(kv.Value)),
|
||||
JsonArray a => a.Any(AnyNote),
|
||||
_ => false,
|
||||
};
|
||||
|
||||
private static async Task<(string Read, string List)> BodiesAsync(DeskWebApplicationFactory factory, string account)
|
||||
{
|
||||
var entry = NotedEntry();
|
||||
factory.Door.ReadScript = (_, _) => new DeskReadOutcome.Found(entry);
|
||||
factory.Door.ListScript = (_, r) => new DeskListOutcome.Listed(
|
||||
new ForkList("gamecult.fork.list.v0", r.Mind, "s1", 1, 0, [entry, entry], null));
|
||||
var token = factory.Token(account, "bifrost-desk", "desk.read");
|
||||
var read = await factory.SendAsync("GET", DeskReplay.Target("read", "gamecult-chat", DeskReplay.ChatFork), null, token);
|
||||
var list = await factory.SendAsync("GET", DeskReplay.Target("list", "gamecult-chat", null), null, token);
|
||||
Assert.Equal(200, read.Status);
|
||||
Assert.Equal(200, list.Status);
|
||||
return (System.Text.Encoding.UTF8.GetString(read.Body), System.Text.Encoding.UTF8.GetString(list.Body));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_non_decider_reads_and_lists_no_notes_anywhere_and_the_body_keeps_the_contract_shape()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Member, true);
|
||||
Assert.DoesNotContain(DeskWebApplicationFactory.Member, DeskWebApplicationFactory.DecidersOf("gamecult-chat"));
|
||||
|
||||
var (read, list) = await BodiesAsync(factory, DeskWebApplicationFactory.Member);
|
||||
|
||||
Assert.DoesNotContain("decider's own words", read);
|
||||
Assert.DoesNotContain("decider's own words", list);
|
||||
Assert.False(AnyNote(JsonNode.Parse(read)));
|
||||
Assert.False(AnyNote(JsonNode.Parse(list)));
|
||||
// Outcomes and cards stay; the key stays written as nil, so the body is still the contract's shape.
|
||||
var expected = JsonSerializer.SerializeToNode(NotedEntry() with
|
||||
{
|
||||
Record = NotedEntry().Record with { Answers = [.. NotedEntry().Record.Answers.Select(a => a with { Note = null })] },
|
||||
}, DeskJson.Options);
|
||||
Assert.True(DeskVectors.SameShape(JsonNode.Parse(read), expected));
|
||||
var answers = JsonNode.Parse(read)!["record"]!["answers"]!.AsArray();
|
||||
Assert.Equal(new[] { "Counted", "Revision", "Retraction", "Refused" }, answers.Select(a => (string)a!["outcome"]!).ToArray());
|
||||
Assert.All(answers, a => Assert.True(a!.AsObject().ContainsKey("note")));
|
||||
Assert.Equal(2, JsonNode.Parse(list)!["forks"]!.AsArray().Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_decider_reads_and_lists_the_notes()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
var (read, list) = await BodiesAsync(factory, DeskWebApplicationFactory.Alice);
|
||||
|
||||
Assert.Contains(Secret + " 3", read);
|
||||
Assert.Equal(8, JsonNode.Parse(list)!["forks"]!.AsArray().Sum(f => f!["record"]!["answers"]!.AsArray().Count(a => a!["note"] is not null)));
|
||||
Assert.True(DeskVectors.SameShape(JsonNode.Parse(read), JsonSerializer.SerializeToNode(NotedEntry(), DeskJson.Options)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Decider_status_is_per_mind_the_same_account_is_stripped_where_it_is_not_on_the_list()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Member, true);
|
||||
Assert.Contains(DeskWebApplicationFactory.Member, DeskWebApplicationFactory.DecidersOf("nibu"));
|
||||
factory.Door.ListScript = (_, r) => new DeskListOutcome.Listed(
|
||||
new ForkList("gamecult.fork.list.v0", r.Mind, "s1", 1, 0, [NotedEntry()], null));
|
||||
var token = factory.Token(DeskWebApplicationFactory.Member, "bifrost-desk", "desk.read");
|
||||
|
||||
var onNibu = await factory.SendAsync("GET", "/api/desk/nibu/forks", null, token);
|
||||
var onChat = await factory.SendAsync("GET", "/api/desk/gamecult-chat/forks", null, token);
|
||||
|
||||
Assert.True(AnyNote(JsonNode.Parse(onNibu.Body)));
|
||||
Assert.False(AnyNote(JsonNode.Parse(onChat.Body)));
|
||||
}
|
||||
}
|
||||
188
tests/Bifrost.Web.Tests/DeskScenarioTests.cs
Normal file
188
tests/Bifrost.Web.Tests/DeskScenarioTests.cs
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskScenarioTests
|
||||
{
|
||||
private static readonly string Socket = DeskWebApplicationFactory.SocketOf("gamecult-chat");
|
||||
|
||||
private static readonly string[] ConfiguredDeciders = DeskWebApplicationFactory.DecidersOf("gamecult-chat");
|
||||
|
||||
// Replays every answer step of every scenario. The door is scripted from the vector's response; what Bifrost
|
||||
// must produce by itself (edge refusals, unavailable, the attached card) is compared with the vector.
|
||||
private sealed record Counts(int Answers, int Edge, int Unavailable, int Skipped);
|
||||
|
||||
private static async Task<Counts> ReplayAsync(Action<string, DeskReply, DeskWebApplicationFactory, JsonObject>? observe = null)
|
||||
{
|
||||
int answers = 0, edge = 0, unavailable = 0, skipped = 0;
|
||||
foreach (var scenario in DeskVectors.Rows("scenarios"))
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
var door = factory.Door;
|
||||
door.Forks[(Socket, DeskReplay.ChatFork)] = DeskReplay.Entry(scenario["card"]!.Deserialize<ForkCard>(DeskJson.Options)!);
|
||||
var scenarioName = (string)scenario["name"]!;
|
||||
|
||||
foreach (var step in scenario["steps"]!.AsArray().Select(s => s!.AsObject()))
|
||||
{
|
||||
var kind = (string)step["kind"]!;
|
||||
if (kind == "matrix_event")
|
||||
{
|
||||
skipped++; // no Matrix ingress exists, so there is no route a Matrix event could take
|
||||
continue;
|
||||
}
|
||||
|
||||
if (kind == "card")
|
||||
{
|
||||
door.Forks[(Socket, DeskReplay.ChatFork)] = DeskReplay.Entry(step["card"]!.Deserialize<ForkCard>(DeskJson.Options)!);
|
||||
continue;
|
||||
}
|
||||
|
||||
var server = step["server"]!.AsObject();
|
||||
var response = step["response"]!.AsObject();
|
||||
var code = (string?)response["code"];
|
||||
var answerer = (string?)server["answerer"];
|
||||
var active = (bool?)server["active"] ?? true;
|
||||
|
||||
door.Calls.Clear();
|
||||
door.StoredIn.Clear();
|
||||
door.Down = false;
|
||||
door.ThrowAfterStore = false;
|
||||
door.AnswerScript = null;
|
||||
if (answerer is not null)
|
||||
{
|
||||
await factory.EnsureAccountAsync(answerer, active);
|
||||
}
|
||||
|
||||
var isDown = (bool?)server["door_down"] == true;
|
||||
var stored = (bool?)server["stored"] == true;
|
||||
if (isDown)
|
||||
{
|
||||
door.Down = !stored;
|
||||
door.ThrowAfterStore = stored;
|
||||
}
|
||||
|
||||
if (code is null)
|
||||
{
|
||||
var wire = response.Deserialize<AnswerResult>(DeskJson.Options)!;
|
||||
// Huginn answers without the card; Bifrost attaches the current one for stale_fork.
|
||||
door.AnswerScript = (_, _, _) => new DeskAnswerOutcome.Answered(wire with { Card = null });
|
||||
}
|
||||
else if (code is "request_id_conflict" or "fork_unknown")
|
||||
{
|
||||
door.AnswerScript = (_, _, _) => new DeskAnswerOutcome.NotStored(code);
|
||||
}
|
||||
|
||||
var body = DeskVectors.Bytes(step["body"]!);
|
||||
var token = answerer is null
|
||||
? null
|
||||
: factory.Token(answerer, "bifrost-desk", "desk.answer");
|
||||
var reply = await factory.SendAsync("POST", DeskReplay.Target("answer", "gamecult-chat", null), body, token);
|
||||
|
||||
var label = $"{scenarioName}";
|
||||
if (code == "unavailable")
|
||||
{
|
||||
unavailable++;
|
||||
Assert.True(503 == reply.Status, $"{label}: {reply.Status}");
|
||||
Assert.Equal("30", reply.Headers.RetryAfter.ToString());
|
||||
Assert.Equal(stored ? [Socket] : [], door.StoredIn);
|
||||
}
|
||||
else if (code is not null && DeskReplay.IsEdgeRefusal(code))
|
||||
{
|
||||
edge++;
|
||||
Assert.True(DeskRefusals.StatusOf(code) == reply.Status, $"{label}: {reply.Status}");
|
||||
Assert.True(door.Calls.Count == 0, $"{label}: the door was called for an edge refusal");
|
||||
}
|
||||
else
|
||||
{
|
||||
answers++;
|
||||
var call = Assert.Single(door.Calls.Where(c => c.Kind == "answer"));
|
||||
Assert.Equal(body, call.Body);
|
||||
Assert.Equal(answerer, call.Context.Subject);
|
||||
Assert.Equal((string)server["authority"]!, call.Context.Authority);
|
||||
Assert.Equal("gamecult-chat", call.Context.Mind);
|
||||
Assert.Equal(ConfiguredDeciders, call.Context.Deciders);
|
||||
Assert.Equal(Socket, call.Socket);
|
||||
}
|
||||
|
||||
Assert.True(
|
||||
DeskVectors.SameShape(JsonNode.Parse(reply.Body), response),
|
||||
$"{label}: response differs\n{reply.Text}\n{response.ToJsonString()}");
|
||||
observe?.Invoke(scenarioName, reply, factory, step);
|
||||
}
|
||||
}
|
||||
|
||||
return new Counts(answers, edge, unavailable, skipped);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Every_scenario_answer_step_replays_through_http()
|
||||
{
|
||||
var counts = await ReplayAsync();
|
||||
|
||||
Assert.Equal(3, counts.Skipped);
|
||||
Assert.Equal(2, counts.Unavailable);
|
||||
Assert.Equal(15, counts.Edge);
|
||||
Assert.Equal(100, counts.Answers);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Edge_refusals_never_call_the_door()
|
||||
{
|
||||
var edges = 0;
|
||||
await ReplayAsync((_, reply, factory, step) =>
|
||||
{
|
||||
var code = (string?)step["response"]!["code"];
|
||||
if (code is not null && DeskReplay.IsEdgeRefusal(code))
|
||||
{
|
||||
edges++;
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
});
|
||||
Assert.Equal(15, edges);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Answer_results_pass_through_unchanged()
|
||||
{
|
||||
var checkedResults = 0;
|
||||
foreach (var row in DeskVectors.Rows("results"))
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
var message = row["message"]!.AsObject();
|
||||
var answer = message["answer"]!.Deserialize<DeskAnswerDocument>(DeskJson.Options)!;
|
||||
var result = message.Deserialize<AnswerResult>(DeskJson.Options)!;
|
||||
factory.Door.Forks[(Socket, answer.ForkId)] = DeskReplay.Entry(
|
||||
message["card"] is { } card ? card.Deserialize<ForkCard>(DeskJson.Options)! : DeskReplay.Card(answer.ForkId));
|
||||
factory.Door.AnswerScript = (_, _, _) => new DeskAnswerOutcome.Answered(result with { Card = null });
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
var reply = await factory.SendAsync(
|
||||
"POST", DeskReplay.Target("answer", "gamecult-chat", null), DeskReplay.AnswerBody(answer.ForkId),
|
||||
factory.Token(DeskWebApplicationFactory.Alice, "bifrost-desk", "desk.answer"));
|
||||
|
||||
Assert.True((int)row["httpStatus"]! == reply.Status, $"{row["name"]}: {reply.Status}");
|
||||
Assert.True(DeskVectors.SameShape(JsonNode.Parse(reply.Body), message), $"{row["name"]}");
|
||||
checkedResults++;
|
||||
}
|
||||
|
||||
Assert.Equal(6, checkedResults);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Unavailable_before_and_after_store()
|
||||
{
|
||||
// The scenarios hold both: door_down before the store, and door_down after it (the retry then replays).
|
||||
var seen = new List<(bool Stored, int Status)>();
|
||||
await ReplayAsync((_, reply, factory, step) =>
|
||||
{
|
||||
if ((string?)step["response"]!["code"] == "unavailable")
|
||||
{
|
||||
seen.Add(((bool?)step["server"]!["stored"] == true, reply.Status));
|
||||
}
|
||||
});
|
||||
Assert.Equal([(false, 503), (true, 503)], seen.OrderBy(s => s.Stored).ToArray());
|
||||
}
|
||||
}
|
||||
149
tests/Bifrost.Web.Tests/DeskSurfaceTests.cs
Normal file
149
tests/Bifrost.Web.Tests/DeskSurfaceTests.cs
Normal file
|
|
@ -0,0 +1,149 @@
|
|||
using System.Net.Sockets;
|
||||
using System.Text;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
using Microsoft.AspNetCore.Builder;
|
||||
using Microsoft.AspNetCore.Hosting;
|
||||
using Microsoft.AspNetCore.Http;
|
||||
using Microsoft.AspNetCore.Hosting.Server;
|
||||
using Microsoft.AspNetCore.Hosting.Server.Features;
|
||||
using Microsoft.AspNetCore.Http.Features;
|
||||
using Microsoft.AspNetCore.Routing;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskSurfaceTests
|
||||
{
|
||||
private static readonly string AnswerTarget = DeskReplay.Target("answer", "gamecult-chat", null);
|
||||
|
||||
[Fact]
|
||||
public async Task Not_mapped_without_config()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory(configured: false);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
var reply = await factory.SendAsync(
|
||||
"POST", AnswerTarget, DeskReplay.AnswerBody(DeskReplay.ChatFork),
|
||||
factory.Token(DeskWebApplicationFactory.Alice, "bifrost-desk", "desk.answer"));
|
||||
|
||||
Assert.Equal(404, reply.Status);
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
var routes = factory.Services.GetRequiredService<EndpointDataSource>().Endpoints.OfType<RouteEndpoint>();
|
||||
Assert.DoesNotContain(routes, e => e.RoutePattern.RawText!.StartsWith("/api/desk", StringComparison.Ordinal));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_configured_desk_without_its_ports_stops_startup()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory(registerPorts: false);
|
||||
|
||||
var failure = Assert.ThrowsAny<Exception>(() => factory.CreateClient());
|
||||
|
||||
Assert.Contains("IDeskCredential", failure.ToString());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cookie_session_does_not_authenticate()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
|
||||
// The test host signs every request in as an Active-looking site member through the default scheme. The desk ignores it.
|
||||
var reply = await factory.SendAsync("POST", AnswerTarget, DeskReplay.AnswerBody(DeskReplay.ChatFork));
|
||||
var withCookie = await factory.SendAsync(
|
||||
"POST", AnswerTarget, DeskReplay.AnswerBody(DeskReplay.ChatFork),
|
||||
configure: http => http.Request.Headers.Cookie = "bifrost_session=anything");
|
||||
|
||||
Assert.Equal(401, reply.Status);
|
||||
Assert.Equal(401, withCookie.Status);
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cors_allows_exactly_the_configured_origin_without_credentials()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
DeskReplay.HoldVectorForks(factory.Door);
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
var token = factory.Token(DeskWebApplicationFactory.Alice, "bifrost-desk", "desk.answer");
|
||||
|
||||
var allowed = await factory.SendAsync("POST", AnswerTarget, DeskReplay.AnswerBody(DeskReplay.ChatFork), token, DeskWebApplicationFactory.Origin);
|
||||
var refused = await factory.SendAsync("POST", AnswerTarget, DeskReplay.AnswerBody(DeskReplay.ChatFork), token, "https://evil.example");
|
||||
var lookalike = await factory.SendAsync("POST", AnswerTarget, DeskReplay.AnswerBody(DeskReplay.ChatFork), token, DeskWebApplicationFactory.Origin + ".evil.example");
|
||||
var preflight = await factory.SendAsync("OPTIONS", AnswerTarget, null, null, DeskWebApplicationFactory.Origin, http =>
|
||||
{
|
||||
http.Request.Headers["Access-Control-Request-Method"] = "POST";
|
||||
http.Request.Headers["Access-Control-Request-Headers"] = "authorization,content-type";
|
||||
});
|
||||
var elsewhere = await factory.SendAsync("GET", "/healthz", null, null, DeskWebApplicationFactory.Origin);
|
||||
|
||||
Assert.Equal(DeskWebApplicationFactory.Origin, allowed.Headers.AccessControlAllowOrigin.ToString());
|
||||
Assert.False(allowed.Headers.ContainsKey("Access-Control-Allow-Credentials"));
|
||||
Assert.Contains("Origin", allowed.Headers.Vary.ToString());
|
||||
Assert.False(refused.Headers.ContainsKey("Access-Control-Allow-Origin"));
|
||||
Assert.False(lookalike.Headers.ContainsKey("Access-Control-Allow-Origin"));
|
||||
Assert.Equal(DeskWebApplicationFactory.Origin, preflight.Headers.AccessControlAllowOrigin.ToString());
|
||||
Assert.False(preflight.Headers.ContainsKey("Access-Control-Allow-Credentials"));
|
||||
Assert.Contains("POST", preflight.Headers.AccessControlAllowMethods.ToString());
|
||||
Assert.False(elsewhere.Headers.ContainsKey("Access-Control-Allow-Origin"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task An_unrecognised_target_is_fork_unknown_and_opens_nothing()
|
||||
{
|
||||
using var factory = new DeskWebApplicationFactory();
|
||||
await factory.EnsureAccountAsync(DeskWebApplicationFactory.Alice, true);
|
||||
var token = factory.Token(DeskWebApplicationFactory.Alice, "bifrost-desk", "desk.answer");
|
||||
|
||||
foreach (var target in new[]
|
||||
{
|
||||
"/api/desk", "/api/desk/", "/api/desk/gamecult-chat", "/api/desk/gamecult-chat/answers/", "/api/desk/a/b/answers",
|
||||
"/api/desk/a/../gamecult-chat/answers", "/api/desk/./gamecult-chat/answers", "/api/desk//answers/x",
|
||||
"/API/DESK/gamecult-chat/answers", "/api/deskx/gamecult-chat/answers", "http://localhost/api/desk/gamecult-chat/answers",
|
||||
})
|
||||
{
|
||||
var reply = await factory.SendAsync("POST", target, DeskReplay.AnswerBody(DeskReplay.ChatFork), token);
|
||||
Assert.True(reply.Status == 404, $"{target}: {reply.Status}");
|
||||
}
|
||||
|
||||
Assert.Empty(factory.Door.Calls);
|
||||
}
|
||||
|
||||
// Kestrel normalises Request.Path but leaves RawTarget as received. The desk parses RawTarget, so a dot
|
||||
// segment can never be folded into a configured Mind's route.
|
||||
[Fact]
|
||||
public async Task Dot_segments_never_reach_the_route()
|
||||
{
|
||||
var builder = WebApplication.CreateBuilder();
|
||||
builder.WebHost.UseUrls("http://127.0.0.1:0");
|
||||
await using var app = builder.Build();
|
||||
app.Run(async http =>
|
||||
{
|
||||
var raw = http.Features.Get<IHttpRequestFeature>()!.RawTarget;
|
||||
var text = $"{http.Request.Path}|{raw}";
|
||||
http.Response.ContentLength = text.Length;
|
||||
await http.Response.WriteAsync(text);
|
||||
});
|
||||
await app.StartAsync();
|
||||
var address = app.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>()!.Addresses.First();
|
||||
var port = new Uri(address).Port;
|
||||
|
||||
using var client = new TcpClient();
|
||||
await client.ConnectAsync("127.0.0.1", port);
|
||||
var stream = client.GetStream();
|
||||
await stream.WriteAsync(Encoding.ASCII.GetBytes("GET /api/desk/ghost/../gamecult-chat/answers HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"));
|
||||
using var reader = new StreamReader(stream, Encoding.ASCII);
|
||||
var text = await reader.ReadToEndAsync();
|
||||
var echoed = text[(text.LastIndexOf("\r\n\r\n", StringComparison.Ordinal) + 4)..].Trim();
|
||||
|
||||
var parts = echoed.Split('|');
|
||||
Assert.Equal("/api/desk/gamecult-chat/answers", parts[0]);
|
||||
Assert.Equal("/api/desk/ghost/../gamecult-chat/answers", parts[1]);
|
||||
Assert.Null(DeskRoute.Parse("POST", parts[1]));
|
||||
Assert.NotNull(DeskRoute.Parse("POST", parts[0]));
|
||||
}
|
||||
}
|
||||
18
tests/Bifrost.Web.Tests/DeskVectorPinTests.cs
Normal file
18
tests/Bifrost.Web.Tests/DeskVectorPinTests.cs
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
using System.Security.Cryptography;
|
||||
using Bifrost.Web.Tests.Support;
|
||||
|
||||
namespace Bifrost.Web.Tests;
|
||||
|
||||
public sealed class DeskVectorPinTests
|
||||
{
|
||||
[Fact]
|
||||
public void Vectors_are_cultlib_89755b08()
|
||||
{
|
||||
var sha = Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(DeskVectors.Path))).ToLowerInvariant();
|
||||
|
||||
Assert.True(
|
||||
DeskVectors.FileSha256 == sha,
|
||||
$"fork-card-vectors.json is not CultLib {DeskVectors.SourceCommit}:contracts/cultnet/governance/fork-card-vectors.json (sha256 {sha}). " +
|
||||
"Re-vendor from that commit or move the pin on purpose, with the whole contract.");
|
||||
}
|
||||
}
|
||||
16970
tests/Bifrost.Web.Tests/Fixtures/fork-card-vectors.json
Normal file
16970
tests/Bifrost.Web.Tests/Fixtures/fork-card-vectors.json
Normal file
File diff suppressed because one or more lines are too long
|
|
@ -362,7 +362,8 @@ public sealed class HostTrustTests : IClassFixture<TestWebApplicationFactory>
|
|||
MintPermits = mintPermits,
|
||||
MintWindow = mintWindow ?? TimeSpan.FromHours(1),
|
||||
MaxTrackedKeys = maxTrackedKeys
|
||||
})).Validate();
|
||||
}),
|
||||
Options.Create(new DeskOptions())).Validate();
|
||||
}
|
||||
|
||||
private sealed class StubHostEnvironment(string environmentName) : IHostEnvironment
|
||||
|
|
|
|||
75
tests/Bifrost.Web.Tests/Support/DeskReplay.cs
Normal file
75
tests/Bifrost.Web.Tests/Support/DeskReplay.cs
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
|
||||
namespace Bifrost.Web.Tests.Support;
|
||||
|
||||
// Shared plumbing for replaying CultLib's transport vectors through HTTP.
|
||||
public static class DeskReplay
|
||||
{
|
||||
public const string ChatFork = "gamecult-chat:question:slot-mark-consent";
|
||||
|
||||
private static JsonNode BaseCard => DeskVectors.Root["scenarios"]![0]!["card"]!;
|
||||
|
||||
public static ForkCard Card(string forkId, string title = "Slot mark consent")
|
||||
{
|
||||
var card = JsonNode.Parse(BaseCard.ToJsonString())!.AsObject();
|
||||
card["fork_id"] = forkId;
|
||||
card["title"] = title;
|
||||
return card.Deserialize<ForkCard>(DeskJson.Options)!;
|
||||
}
|
||||
|
||||
public static ForkEntry Entry(ForkCard card) => new(
|
||||
"gamecult.fork.entry.v0",
|
||||
card,
|
||||
new ForkRecord("gamecult.fork.record.v0", card.ForkId, card.OptionsHash, null, []));
|
||||
|
||||
// Every fork the vectors say each Mind holds, on that Mind's socket.
|
||||
public static void HoldVectorForks(FakeDeskDoor door)
|
||||
{
|
||||
var forks = DeskVectors.Root["transport"]!["mindRoutes"]!["forks"]!.AsObject();
|
||||
foreach (var (mind, ids) in forks)
|
||||
{
|
||||
foreach (var id in ids!.AsArray())
|
||||
{
|
||||
door.Forks[(DeskWebApplicationFactory.SocketOf(mind), (string)id!)] = Entry(Card((string)id!));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static byte[] AnswerBody(string forkId, string requestId = "00000001-0000-4000-8000-000000000001")
|
||||
{
|
||||
var body = JsonNode.Parse(DeskVectors.Root["scenarios"]![0]!["steps"]![0]!["body"]!.ToJsonString())!.AsObject();
|
||||
body["fork_id"] = forkId;
|
||||
body["request_id"] = requestId;
|
||||
return DeskVectors.Bytes(body);
|
||||
}
|
||||
|
||||
// The raw segment as it would travel in one path segment: a literal '/' cannot, so it is sent as %2F.
|
||||
public static string SegmentOnWire(string rawMind) => rawMind.Replace("/", "%2F", StringComparison.Ordinal);
|
||||
|
||||
public static string Target(string route, string rawMind, string? forkId) => route switch
|
||||
{
|
||||
"answer" => $"/api/desk/{SegmentOnWire(rawMind)}/answers",
|
||||
"list" => $"/api/desk/{SegmentOnWire(rawMind)}/forks",
|
||||
"read" => $"/api/desk/{SegmentOnWire(rawMind)}/forks/{Uri.EscapeDataString(forkId!)}",
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(route)),
|
||||
};
|
||||
|
||||
// Seeds the account the vector token stands for and returns the header value (null for no token).
|
||||
public static async Task<string?> TokenAsync(DeskWebApplicationFactory factory, JsonNode? token)
|
||||
{
|
||||
if (token is null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var active = (bool)token["active"]!;
|
||||
var subject = active ? DeskWebApplicationFactory.Alice : DeskWebApplicationFactory.Member;
|
||||
await factory.EnsureAccountAsync(subject, active);
|
||||
return factory.Token(subject, (string)token["audience"]!, token["scopes"]!.AsArray().Select(s => (string)s!).ToArray());
|
||||
}
|
||||
|
||||
public static bool IsEdgeRefusal(string code) =>
|
||||
code is "unauthenticated" or "insufficient_scope" or "forbidden" or "body_forbidden_field" or "body_unknown_field" or "body_invalid";
|
||||
}
|
||||
50
tests/Bifrost.Web.Tests/Support/DeskVectors.cs
Normal file
50
tests/Bifrost.Web.Tests/Support/DeskVectors.cs
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace Bifrost.Web.Tests.Support;
|
||||
|
||||
// CultLib's fork-card vectors, vendored at commit 89755b08b5dd4bf72ed8e5907b5ff4717e51da12.
|
||||
public static class DeskVectors
|
||||
{
|
||||
public const string SourceCommit = "89755b08b5dd4bf72ed8e5907b5ff4717e51da12";
|
||||
|
||||
public const string FileSha256 = "3387debd16059621202b706761519231e7ad52d0d4bd071a32b80c0d916e42fa";
|
||||
|
||||
public static string Path => System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", "fork-card-vectors.json");
|
||||
|
||||
public static JsonNode Root { get; } = JsonNode.Parse(File.ReadAllBytes(Path))!;
|
||||
|
||||
public static JsonArray Array(params string[] path)
|
||||
{
|
||||
JsonNode node = Root;
|
||||
foreach (var step in path)
|
||||
{
|
||||
node = node[step]!;
|
||||
}
|
||||
|
||||
return node.AsArray();
|
||||
}
|
||||
|
||||
public static IEnumerable<JsonObject> Rows(params string[] path) => Array(path).Select(row => row!.AsObject());
|
||||
|
||||
// True when both are the same JSON with the same keys in the same order.
|
||||
public static bool SameShape(JsonNode? left, JsonNode? right)
|
||||
{
|
||||
switch (left, right)
|
||||
{
|
||||
case (null, null):
|
||||
return true;
|
||||
case (JsonObject a, JsonObject b):
|
||||
return a.Select(p => p.Key).SequenceEqual(b.Select(p => p.Key)) &&
|
||||
a.All(p => SameShape(p.Value, b[p.Key]));
|
||||
case (JsonArray a, JsonArray b):
|
||||
return a.Count == b.Count && a.Zip(b).All(pair => SameShape(pair.First, pair.Second));
|
||||
case (JsonValue, JsonValue):
|
||||
return JsonNode.DeepEquals(left, right);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public static byte[] Bytes(JsonNode node) => System.Text.Encoding.UTF8.GetBytes(node.ToJsonString());
|
||||
}
|
||||
182
tests/Bifrost.Web.Tests/Support/DeskWebApplicationFactory.cs
Normal file
182
tests/Bifrost.Web.Tests/Support/DeskWebApplicationFactory.cs
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
using System.Text;
|
||||
using Bifrost.Web.Data;
|
||||
using Bifrost.Web.Domain;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
using Microsoft.AspNetCore.Hosting;
|
||||
using Microsoft.AspNetCore.Http;
|
||||
using Microsoft.AspNetCore.Http.Features;
|
||||
using Microsoft.AspNetCore.TestHost;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
|
||||
namespace Bifrost.Web.Tests.Support;
|
||||
|
||||
public sealed record DeskReply(int Status, string ContentType, byte[] Body, IHeaderDictionary Headers)
|
||||
{
|
||||
public string Text => Encoding.UTF8.GetString(Body);
|
||||
}
|
||||
|
||||
// The app with the Desk section configured and the two ports faked. `Configuration` is the Desk section as
|
||||
// key/value pairs; null leaves the Desk section out, `RegisterPorts` false leaves the ports unregistered.
|
||||
public sealed class DeskWebApplicationFactory : TestWebApplicationFactory
|
||||
{
|
||||
public const string Alice = "e0d1c2b3-a495-4687-8879-6a5b4c3d2e1f";
|
||||
public const string Steward = "9f8e7d6c-5b4a-4392-8170-0f1e2d3c4b5a";
|
||||
public const string Member = "11111111-2222-4333-8444-555555555555";
|
||||
public const string Origin = "https://chat.gamecult.org";
|
||||
|
||||
private readonly Dictionary<string, string?>? configuration;
|
||||
private readonly bool registerPorts;
|
||||
|
||||
public DeskWebApplicationFactory(Dictionary<string, string?>? configuration = null, bool configured = true, bool registerPorts = true)
|
||||
{
|
||||
this.configuration = configured ? configuration ?? DefaultConfiguration() : null;
|
||||
this.registerPorts = registerPorts;
|
||||
}
|
||||
|
||||
public FakeDeskDoor Door { get; } = new();
|
||||
|
||||
public FakeDeskCredential Credential { get; } = new();
|
||||
|
||||
|
||||
public static Dictionary<string, string?> DefaultConfiguration()
|
||||
{
|
||||
var values = new Dictionary<string, string?>
|
||||
{
|
||||
["Desk:AllowedOrigin"] = Origin,
|
||||
["Desk:RetryAfterSeconds"] = "30",
|
||||
["Desk:Attribution:Operator"] = Alice,
|
||||
["Desk:Attribution:Stewards:0"] = Steward,
|
||||
};
|
||||
var i = 0;
|
||||
foreach (var mind in DeskVectors.Root["transport"]!["mindRoutes"]!["minds"]!.AsObject())
|
||||
{
|
||||
values[$"Desk:Minds:{i}:Id"] = mind.Key;
|
||||
values[$"Desk:Minds:{i}:Socket"] = SocketOf(mind.Key);
|
||||
var deciders = DecidersOf(mind.Key);
|
||||
for (var d = 0; d < deciders.Length; d++)
|
||||
{
|
||||
values[$"Desk:Minds:{i}:Deciders:{d}"] = deciders[d];
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
return values;
|
||||
}
|
||||
|
||||
// A distinct list per Mind (different members, order and length), so a door context that carries another
|
||||
// Mind's list cannot pass for the route Mind's.
|
||||
public static string[] DecidersOf(string mindId) =>
|
||||
mindId == "nibu" ? [Steward, Alice, Member] : [Alice, Steward];
|
||||
|
||||
public static string SocketOf(string mindId) =>
|
||||
"/run/huginn/" + (string)DeskVectors.Root["transport"]!["mindRoutes"]!["minds"]![mindId]!;
|
||||
|
||||
protected override void ConfigureWebHost(IWebHostBuilder builder)
|
||||
{
|
||||
base.ConfigureWebHost(builder);
|
||||
if (configuration is not null)
|
||||
{
|
||||
foreach (var (key, value) in configuration)
|
||||
{
|
||||
builder.UseSetting(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
if (registerPorts)
|
||||
{
|
||||
builder.ConfigureServices(services =>
|
||||
{
|
||||
services.AddSingleton<IDeskCredential>(Credential);
|
||||
services.AddSingleton<IDeskDoor>(Door);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Upserts the account with an Active (or Suspended) membership.
|
||||
public async Task EnsureAccountAsync(string id, bool active)
|
||||
{
|
||||
using var scope = Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<BifrostDbContext>();
|
||||
var guid = Guid.Parse(id);
|
||||
var account = await db.UserAccounts.FindAsync(guid);
|
||||
if (account is null)
|
||||
{
|
||||
account = new UserAccount { Id = guid, GitHubLogin = "desk-" + id[..8], NormalizedGitHubLogin = "desk-" + id[..8], BifrostIdentity = "desk-" + id, NormalizedBifrostIdentity = "desk-" + id };
|
||||
db.UserAccounts.Add(account);
|
||||
db.Memberships.Add(new Domain.Membership { UserAccountId = guid, Status = active ? MembershipStatus.Active : MembershipStatus.Suspended });
|
||||
}
|
||||
else
|
||||
{
|
||||
var membership = db.Memberships.Single(m => m.UserAccountId == guid);
|
||||
membership.Status = active ? MembershipStatus.Active : MembershipStatus.Suspended;
|
||||
}
|
||||
|
||||
await db.SaveChangesAsync();
|
||||
}
|
||||
|
||||
public string Token(string? subject, string? audience, params string[] scopes) =>
|
||||
FakeDeskCredential.Encode(subject, audience, scopes);
|
||||
|
||||
// What routing would see for a raw path. Kestrel refuses a NUL or a malformed escape before routing; the
|
||||
// placeholder keeps the request inside /api/desk so the handler's own judgment is what the test observes.
|
||||
private static PathString RoutedPath(string rawPath)
|
||||
{
|
||||
var schemeEnd = rawPath.IndexOf("://", StringComparison.Ordinal);
|
||||
if (schemeEnd > 0)
|
||||
{
|
||||
var pathStart = rawPath.IndexOf('/', schemeEnd + 3);
|
||||
rawPath = pathStart < 0 ? "/" : rawPath[pathStart..];
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return PathString.FromUriComponent(rawPath);
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
return new PathString("/api/desk/_");
|
||||
}
|
||||
}
|
||||
|
||||
// Sends one request with the RAW target set exactly as given (TestServer's HttpClient sets none). `path` is
|
||||
// what routing sees; production Kestrel would hand over the decoded path the same way.
|
||||
public async Task<DeskReply> SendAsync(
|
||||
string method, string rawTarget, byte[]? body = null, string? token = null, string? origin = null,
|
||||
Action<HttpContext>? configure = null)
|
||||
{
|
||||
var context = await Server.SendAsync(http =>
|
||||
{
|
||||
http.Request.Method = method;
|
||||
http.Request.Scheme = "https";
|
||||
http.Request.Host = new HostString("localhost");
|
||||
var query = rawTarget.IndexOf('?');
|
||||
var rawPath = query >= 0 ? rawTarget[..query] : rawTarget;
|
||||
http.Request.Path = RoutedPath(rawPath);
|
||||
http.Request.QueryString = query >= 0 ? new QueryString(rawTarget[query..]) : QueryString.Empty;
|
||||
http.Features.GetRequiredFeature<IHttpRequestFeature>().RawTarget = rawTarget;
|
||||
if (token is not null)
|
||||
{
|
||||
http.Request.Headers[FakeDeskCredential.Header] = token;
|
||||
}
|
||||
|
||||
if (origin is not null)
|
||||
{
|
||||
http.Request.Headers.Origin = origin;
|
||||
}
|
||||
|
||||
if (body is not null)
|
||||
{
|
||||
http.Request.Body = new MemoryStream(body);
|
||||
http.Request.ContentLength = body.Length;
|
||||
http.Request.ContentType = "application/json";
|
||||
}
|
||||
|
||||
configure?.Invoke(http);
|
||||
});
|
||||
|
||||
using var buffer = new MemoryStream();
|
||||
await context.Response.Body.CopyToAsync(buffer);
|
||||
return new DeskReply(context.Response.StatusCode, context.Response.ContentType ?? string.Empty, buffer.ToArray(), context.Response.Headers);
|
||||
}
|
||||
}
|
||||
42
tests/Bifrost.Web.Tests/Support/FakeDeskCredential.cs
Normal file
42
tests/Bifrost.Web.Tests/Support/FakeDeskCredential.cs
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
using Microsoft.AspNetCore.Http;
|
||||
using System.Text.Json;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
|
||||
namespace Bifrost.Web.Tests.Support;
|
||||
|
||||
// A header-driven stand-in for the bearer validation port. X-Test-Desk-Token carries {sub, aud, scopes}; no header
|
||||
// means no valid token. It validates nothing: the desk's own judgments (audience, scope, membership) are the subject.
|
||||
public sealed class FakeDeskCredential : IDeskCredential
|
||||
{
|
||||
public const string Header = "X-Test-Desk-Token";
|
||||
|
||||
public static string Encode(string? subject, string? audience, IEnumerable<string> scopes) =>
|
||||
JsonSerializer.Serialize(new { sub = subject, aud = audience, scopes });
|
||||
|
||||
// The port fails (its key source is down), instead of answering.
|
||||
public bool Throws { get; set; }
|
||||
|
||||
// Runs when a request reaches the port, after the host's own middleware: a test breaks what comes next.
|
||||
public Action<HttpContext>? OnAuthenticate { get; set; }
|
||||
|
||||
public ValueTask<DeskToken?> AuthenticateAsync(HttpContext context, CancellationToken cancellationToken)
|
||||
{
|
||||
if (Throws)
|
||||
{
|
||||
throw new InvalidOperationException("the credential port is down");
|
||||
}
|
||||
|
||||
OnAuthenticate?.Invoke(context);
|
||||
if (!context.Request.Headers.TryGetValue(Header, out var raw))
|
||||
{
|
||||
return ValueTask.FromResult<DeskToken?>(null);
|
||||
}
|
||||
|
||||
using var document = JsonDocument.Parse(raw.ToString());
|
||||
var root = document.RootElement;
|
||||
return ValueTask.FromResult<DeskToken?>(new DeskToken(
|
||||
root.GetProperty("sub").GetString(),
|
||||
root.GetProperty("aud").GetString(),
|
||||
root.GetProperty("scopes").EnumerateArray().Select(s => s.GetString()!).ToArray()));
|
||||
}
|
||||
}
|
||||
125
tests/Bifrost.Web.Tests/Support/FakeDeskDoor.cs
Normal file
125
tests/Bifrost.Web.Tests/Support/FakeDeskDoor.cs
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
using System.Text.Json.Nodes;
|
||||
using Bifrost.Web.Features.Desk;
|
||||
|
||||
namespace Bifrost.Web.Tests.Support;
|
||||
|
||||
public sealed record DeskDoorCall(string Kind, string Socket, DeskDoorContext Context, byte[]? Body, string? ForkId, DeskListRequest? List = null);
|
||||
|
||||
// The door as a test double: it records every call, holds the forks each socket's Mind holds, and by default stores
|
||||
// an answer to a held fork as Counted. A test may script the outcome or make the door fail before or after storing.
|
||||
public sealed class FakeDeskDoor : IDeskDoor
|
||||
{
|
||||
private readonly object gate = new();
|
||||
|
||||
public List<DeskDoorCall> Calls { get; } = [];
|
||||
|
||||
public List<string> StoredIn { get; } = [];
|
||||
|
||||
public Dictionary<(string Socket, string ForkId), ForkEntry> Forks { get; } = [];
|
||||
|
||||
public Func<string, DeskDoorContext, byte[], DeskAnswerOutcome>? AnswerScript { get; set; }
|
||||
|
||||
// Every call throws (Huginn is down).
|
||||
public bool Down { get; set; }
|
||||
|
||||
// The answer is stored, then the door throws (a timeout after send).
|
||||
public bool ThrowAfterStore { get; set; }
|
||||
|
||||
public bool ThrowOnRead { get; set; }
|
||||
|
||||
public Func<string, string, DeskReadOutcome>? ReadScript { get; set; }
|
||||
|
||||
public Func<string, DeskListRequest, DeskListOutcome>? ListScript { get; set; }
|
||||
|
||||
public Task<DeskListOutcome> ListAsync(
|
||||
string socket, DeskDoorContext context, DeskListRequest request, CancellationToken cancellationToken)
|
||||
{
|
||||
lock (gate)
|
||||
{
|
||||
Calls.Add(new DeskDoorCall("list", socket, context, null, null, request));
|
||||
}
|
||||
|
||||
if (Down)
|
||||
{
|
||||
throw new IOException("huginn is down");
|
||||
}
|
||||
|
||||
return Task.FromResult(ListScript?.Invoke(socket, request)
|
||||
?? new DeskListOutcome.Listed(new ForkList("gamecult.fork.list.v0", request.Mind, "s1", 0, 0, [], null)));
|
||||
}
|
||||
|
||||
public Task<DeskAnswerOutcome> AnswerAsync(
|
||||
string socket, DeskDoorContext context, ReadOnlyMemory<byte> body, CancellationToken cancellationToken)
|
||||
{
|
||||
var bytes = body.ToArray();
|
||||
lock (gate)
|
||||
{
|
||||
Calls.Add(new DeskDoorCall("answer", socket, context, bytes, null));
|
||||
}
|
||||
|
||||
if (Down)
|
||||
{
|
||||
throw new IOException("huginn is down");
|
||||
}
|
||||
|
||||
var outcome = AnswerScript?.Invoke(socket, context, bytes) ?? HeldForkOutcome(socket, context, bytes);
|
||||
if (outcome is DeskAnswerOutcome.Answered)
|
||||
{
|
||||
lock (gate)
|
||||
{
|
||||
StoredIn.Add(socket);
|
||||
}
|
||||
}
|
||||
|
||||
if (ThrowAfterStore)
|
||||
{
|
||||
throw new TimeoutException("the door timed out after send");
|
||||
}
|
||||
|
||||
return Task.FromResult(outcome);
|
||||
}
|
||||
|
||||
public Task<DeskReadOutcome> ReadAsync(
|
||||
string socket, DeskDoorContext context, string forkId, CancellationToken cancellationToken)
|
||||
{
|
||||
lock (gate)
|
||||
{
|
||||
Calls.Add(new DeskDoorCall("read", socket, context, null, forkId));
|
||||
}
|
||||
|
||||
if (Down || ThrowOnRead)
|
||||
{
|
||||
throw new IOException("huginn is down");
|
||||
}
|
||||
|
||||
if (ReadScript is not null)
|
||||
{
|
||||
return Task.FromResult(ReadScript(socket, forkId));
|
||||
}
|
||||
|
||||
return Task.FromResult<DeskReadOutcome>(Forks.TryGetValue((socket, forkId), out var entry)
|
||||
? new DeskReadOutcome.Found(entry)
|
||||
: new DeskReadOutcome.NotFound(DeskRefusals.ForkUnknown));
|
||||
}
|
||||
|
||||
private DeskAnswerOutcome HeldForkOutcome(string socket, DeskDoorContext context, byte[] body)
|
||||
{
|
||||
var request = JsonNode.Parse(body)!.AsObject();
|
||||
var forkId = (string)request["fork_id"]!;
|
||||
if (!Forks.ContainsKey((socket, forkId)))
|
||||
{
|
||||
return new DeskAnswerOutcome.NotStored(DeskRefusals.ForkUnknown);
|
||||
}
|
||||
|
||||
var answer = request["answer"]?.AsObject();
|
||||
return new DeskAnswerOutcome.Answered(new AnswerResult(
|
||||
DeskSchemas.AnswerResult,
|
||||
new DeskAnswerDocument(
|
||||
DeskSchemas.DeskAnswer, "n1", forkId, "Counted", null, null, null,
|
||||
(string)request["options_hash"]!, (string?)answer?["choice"], (string?)answer?["note"],
|
||||
(string)request["answered_at"]!, "2026-11-12T19:02:05Z", false,
|
||||
context.Subject, context.Authority, (string)request["request_id"]!),
|
||||
null,
|
||||
"n1"));
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue