Files
Anubis/tests/Anubis.Tests/DependencyPolicyTests.cs
Alby96andClaude Opus 5.5 78e77818eb
ci / test (postgres) (push) Failing after 6m20s
ci / test (sqlite) (push) Failing after 5m59s
ci / image (push) Skipped
ci / test (postgres) (pull_request) Failing after 4m51s
ci / test (sqlite) (pull_request) Successful in 5m29s
ci / image (pull_request) Skipped
Read the tone of English headlines with the pinned ONNX model of SPEC 4.5 (refs #57)
The classifier is distilroberta-finetuned-financial-news-sentiment-analysis in
Xenova's quantized ONNX export, pinned at revision e6953e30 and checked by size and
SHA-256.

- Model download: the model is not in the repository. The news job downloads it in
  the background into the models folder of the data directory, the first time, and
  retries after 6 hours if that fails. Until then the keywords judge alone, as
  SPEC 10.3 requires.
- Tokenizer: RoBERTa's byte-level BPE travels inside the DLL, read with
  BpeTokenizer and the RoBERTa pre-tokenizer. CodeGenTokenizer.Create adds ids for
  runs of spaces that the model rejects. No special tokens are recognised in
  untrusted text.
- Token check: the test compares the ids on 14 headlines with an independent copy
  of the GPT-2 encoder run on the same files.
- Model test: it reads the tone of clear headlines at 23-24 ms per title on one
  thread. It runs where the model is already downloaded and is skipped in CI.

Microsoft.ML.OnnxRuntime 1.31.1 and Microsoft.ML.Tokenizers 2.0.1 come from the
ADR 0004 list. Google.Protobuf joins the known indirect dependencies.

Anubis and Anubis.Server now declare win-x64 among their runtime identifiers, so
their lock files hold the Windows native packages. Publishing the Windows zip no
longer rewrites the lock files.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 12:00:54 +01:00

149 lines
6.6 KiB
C#

using System.Text.Json;
using System.Xml.Linq;
namespace Anubis.Tests;
/// <summary>ADR 0004 and 0006: only the packages the user authorised, and nothing else sneaking in.</summary>
[TestClass]
public sealed class DependencyPolicyTests
{
/// <summary>The list of ADR 0004 as precised by ADR 0006. Changing it needs the user's permission and a new ADR.</summary>
private static readonly HashSet<string> _authorised = new(StringComparer.OrdinalIgnoreCase)
{
"Microsoft.Data.Sqlite",
"System.Security.Cryptography.ProtectedData",
"Microsoft.Web.WebView2",
"MSTest.TestFramework",
"MSTest.TestAdapter",
"Microsoft.NET.Test.Sdk",
"Npgsql",
"Microsoft.ML",
"Microsoft.ML.LightGbm",
"Microsoft.ML.FastTree",
"Microsoft.ML.OnnxRuntime",
"Microsoft.ML.Tokenizers",
};
/// <summary>
/// Third-party packages pulled in by an authorised one. Each must also be listed in docs/API-NOTES.md
/// and reported to the user (checked below). Microsoft.* and System.* ids are reserved to Microsoft on nuget.org.
/// </summary>
private static readonly HashSet<string> _knownThirdPartyTransitive = new(StringComparer.OrdinalIgnoreCase)
{
// Native SQLite library and its loader, brought by Microsoft.Data.Sqlite (phase 1).
"SQLitePCLRaw.bundle_e_sqlite3",
"SQLitePCLRaw.core",
"SQLitePCLRaw.lib.e_sqlite3",
"SQLitePCLRaw.provider.e_sqlite3",
// Protocol buffers, brought by Microsoft.ML.Tokenizers (phase 7).
"Google.Protobuf",
};
private static readonly string[] _packageElements = ["PackageReference", "GlobalPackageReference", "PackageDownload"];
[TestMethod]
[TestCategory(Category.Unit)]
public void CentralVersionsListOnlyAuthorisedPackages()
{
var props = XDocument.Load(Path.Combine(Repo.Root.FullName, "Directory.Packages.props"));
var listed = props.Descendants()
.Where(e => e.Name.LocalName is "PackageVersion" or "GlobalPackageReference")
.Select(e => (string?)e.Attribute("Include") ?? "?")
.ToList();
var notAllowed = listed.Where(id => !_authorised.Contains(id)).ToList();
Assert.IsEmpty(notAllowed, "Pacchetti non autorizzati (ADR 0004): " + string.Join(", ", notAllowed));
}
[TestMethod]
[TestCategory(Category.Unit)]
public void ProjectsDoNotPinVersionsOrBypassTheCentralList()
{
string[] msbuildExtensions = [".csproj", ".props", ".targets"];
var problems = new List<string>();
foreach (var file in Repo.Files().Where(f => msbuildExtensions.Contains(f.Extension, StringComparer.OrdinalIgnoreCase)))
{
var isCentralList = file.Name.Equals("Directory.Packages.props", StringComparison.OrdinalIgnoreCase);
var doc = XDocument.Load(file.FullName);
foreach (var reference in doc.Descendants().Where(e => _packageElements.Contains(e.Name.LocalName)))
{
var id = (string?)reference.Attribute("Include") ?? (string?)reference.Attribute("Update") ?? "?";
if (!_authorised.Contains(id))
{
problems.Add($"{Repo.Relative(file)}: {id} non è autorizzato");
}
var ownVersion = reference.Attribute("Version") is not null
|| reference.Attribute("VersionOverride") is not null
|| reference.Elements().Any(e => e.Name.LocalName is "Version" or "VersionOverride");
if (ownVersion && !isCentralList)
{
problems.Add($"{Repo.Relative(file)}: {id} ha una versione propria");
}
}
}
Assert.IsEmpty(problems, string.Join(Environment.NewLine, problems));
}
[TestMethod]
[TestCategory(Category.Unit)]
public void LockFilesContainOnlyAuthorisedDirectPackagesAndKnownIndirectOnes()
{
var lockFiles = Repo.Files().Where(f => f.Name.Equals("packages.lock.json", StringComparison.OrdinalIgnoreCase)).ToList();
Assert.IsNotEmpty(lockFiles, "Nessun packages.lock.json: i file di blocco devono essere nel repository.");
var problems = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var file in lockFiles)
{
using var doc = JsonDocument.Parse(File.ReadAllText(file.FullName));
foreach (var framework in doc.RootElement.GetProperty("dependencies").EnumerateObject())
{
foreach (var package in framework.Value.EnumerateObject())
{
var type = package.Value.TryGetProperty("type", out var t) ? t.GetString() : null;
var id = package.Name;
switch (type)
{
case "Project":
break;
case "Direct" or "CentralTransitive":
// Whatever a project asks for directly must be on the list, Microsoft or not.
if (!_authorised.Contains(id))
{
problems.Add($"{id} diretto non autorizzato (in {Repo.Relative(file)})");
}
break;
default:
if (!_authorised.Contains(id) && !IsMicrosoftId(id) && !_knownThirdPartyTransitive.Contains(id))
{
problems.Add($"{id} indiretto di terze parti non dichiarato (in {Repo.Relative(file)})");
}
break;
}
}
}
}
Assert.IsEmpty(problems, string.Join(", ", problems));
}
[TestMethod]
[TestCategory(Category.Unit)]
public void KnownThirdPartyPackagesAreDocumentedInApiNotes()
{
var notes = File.ReadAllText(Path.Combine(Repo.Root.FullName, "docs", "API-NOTES.md"));
var missing = _knownThirdPartyTransitive.Where(id => !notes.Contains($"`{id}`", StringComparison.OrdinalIgnoreCase)).ToList();
Assert.IsEmpty(missing, "Dipendenze di terze parti non elencate in docs/API-NOTES.md: " + string.Join(", ", missing));
}
private static bool IsMicrosoftId(string id) =>
id.StartsWith("Microsoft.", StringComparison.OrdinalIgnoreCase)
|| id.StartsWith("System.", StringComparison.OrdinalIgnoreCase)
|| id.StartsWith("MSTest.", StringComparison.OrdinalIgnoreCase)
|| id.Equals("NETStandard.Library", StringComparison.OrdinalIgnoreCase);
}