Files
Febe/tests/Febe.Tests/Collection/SignalTests.cs
T

179 lines
9.7 KiB
C#

using System.Text.Json;
using Febe.Core.Abstractions;
using Febe.Core.Collection;
using Febe.Tests.Browser.TestSupport;
namespace Febe.Tests.Collection;
[TestClass]
public sealed class SignalTests
{
[TestMethod]
public void ShippedRulesLoadFromResourcesAndFromTheConfigFolder()
{
var embedded = SignalRules.LoadDefault();
Assert.IsTrue(embedded.Rules.Any(r => r.Statuses.Contains(429) && r.Level == SignalLevel.Throttle));
Assert.IsTrue(embedded.Rules.Where(r => r.Path is not null || r.Text is not null).All(r => r.Hypothesis == "H8"),
"Every Instagram-specific pattern is marked as hypothesis H8.");
Assert.IsNotNull(embedded.EmptyPages);
var onDisk = Path.Combine(AppContext.BaseDirectory, "config", "segnali.json");
Assert.IsTrue(File.Exists(onDisk), "segnali.json is copied next to the program, editable without recompiling.");
Assert.AreEqual(embedded.Rules.Count, SignalRules.Load(onDisk).Rules.Count);
Assert.AreEqual(embedded.Rules.Count, SignalRules.LoadOrDefault(Path.Combine(AppContext.BaseDirectory, "manca.json")).Rules.Count);
var testSite = SignalRules.LoadTestSite();
Assert.IsTrue(File.Exists(Path.Combine(AppContext.BaseDirectory, "config", "segnali.prova.json")));
Assert.AreEqual(5, testSite.Rules.Count);
Assert.IsTrue(testSite.Rules.Any(r => r.Code == "session-ended-url" && r.Level == SignalLevel.Disconnect));
}
[TestMethod]
public void TestSiteSignalsMapToTheRightLevels()
{
var (detector, breaker, clock) = Create();
Assert.AreEqual(SignalLevel.Throttle, detector.ObserveResponse(Response("/api/feed", 429))?.Level);
Assert.AreEqual(SignalLevel.Challenge, detector.ObserveNavigation(Navigation("/verifica/"))?.Level);
Assert.AreEqual(SignalLevel.Disconnect, detector.ObserveNavigation(Navigation("/accesso"))?.Level);
Assert.AreEqual(3, breaker.Signals.Count);
Assert.AreEqual("http-429", breaker.Signals[0].Code);
Assert.AreEqual("http://127.0.0.1:5000/api/feed", breaker.Signals[0].Url, "Address without query string.");
Assert.AreEqual(clock.Now, breaker.Signals[0].At);
}
[TestMethod]
public void OrdinaryTrafficRaisesNothing()
{
var (detector, breaker, _) = Create();
Assert.IsNull(detector.ObserveResponse(Response("/api/feed", 200)));
Assert.IsNull(detector.ObserveResponse(Response("/verifica", 200, mainDocument: false)), "Path rules look at navigations and page loads only.");
Assert.IsNull(detector.ObserveNavigation(Navigation("/profilo/verifica-mente/")));
Assert.IsNull(detector.ObserveResponse(Response("/x", 429, HostKind.Other)), "Third-party hosts are not the site.");
Assert.AreEqual(0, breaker.Signals.Count);
}
[TestMethod]
public void TheSameSignalIsReportedOncePerWindow()
{
var (detector, breaker, clock) = Create();
Assert.IsNotNull(detector.ObserveResponse(Response("/a", 429)));
Assert.IsNull(detector.ObserveResponse(Response("/b", 429)));
Assert.IsNotNull(detector.ObserveResponse(Response("/verifica", 200, mainDocument: true)), "Another code is reported.");
clock.Advance(TimeSpan.FromMinutes(2));
Assert.IsNotNull(detector.ObserveResponse(Response("/c", 429)));
Assert.AreEqual(3, breaker.Signals.Count);
}
[TestMethod]
public void WaitTextIsFoundOnlyInShortResponses()
{
var (detector, breaker, _) = Create();
using var shortBody = JsonDocument.Parse("""{ "stato": "errore", "messaggio": "Attendi qualche minuto prima di riprovare." }""");
Assert.AreEqual(SignalLevel.Throttle, detector.ObserveJsonBody(Response("/api", 200), shortBody.RootElement)?.Level);
var (detector2, breaker2, _) = Create();
var caption = "Attendi qualche minuto " + new string('x', 5000);
using var longBody = JsonDocument.Parse(JsonSerializer.Serialize(new { didascalia = caption }));
Assert.IsNull(detector2.ObserveJsonBody(Response("/api", 200), longBody.RootElement), "A long feed with that phrase in a caption is not a signal.");
Assert.AreEqual(1, breaker.Signals.Count);
Assert.AreEqual(0, breaker2.Signals.Count);
}
[TestMethod]
public void RepeatedEmptyPagesThrottle()
{
var (detector, breaker, _) = Create();
Assert.IsNull(detector.ObserveEmptyPage());
Assert.IsNull(detector.ObserveEmptyPage());
detector.ObserveNonEmptyPage();
Assert.IsNull(detector.ObserveEmptyPage());
Assert.IsNull(detector.ObserveEmptyPage());
Assert.AreEqual("empty-pages", detector.ObserveEmptyPage("http://127.0.0.1:5000/griglia?pagina=3")?.Code);
Assert.AreEqual("http://127.0.0.1:5000/griglia", breaker.Signals.Single().Url);
}
[TestMethod]
public void MissingSessionCookieIsADisconnection()
{
var (detector, breaker, _) = Create();
Assert.IsNull(detector.ObserveSessionCookie(true));
Assert.AreEqual(SignalLevel.Disconnect, detector.ObserveSessionCookie(false)?.Level);
Assert.AreEqual(SignalRules.SessionCookieMissingCode, breaker.Signals.Single().Code);
}
[TestMethod]
public void InstagramHypothesesMatchTheirPaths()
{
var clock = new VirtualClock();
var breaker = new RecordingBreaker();
var detector = new SignalDetector(SignalRules.LoadDefault(), breaker, clock);
NavigationDescriptor Nav(string path) => new(HostKind.Site, "https://www.instagram.com" + path, "www.instagram.com", path, clock.Now);
Assert.AreEqual(SignalLevel.Challenge, detector.ObserveNavigation(Nav("/challenge/abc/"))?.Level);
Assert.AreEqual(SignalLevel.Disconnect, detector.ObserveNavigation(Nav("/accounts/login/"))?.Level);
Assert.AreEqual(SignalLevel.Challenge, detector.ObserveNavigation(Nav("/accounts/suspended/"))?.Level);
Assert.IsNull(detector.ObserveNavigation(Nav("/challenger_fan/")), "A username that starts like a rule is not a signal.");
}
[TestMethod]
[DataRow("""{ "rules": [ { "code": "a", "level": "throttle", "status": [429], "path": "^/x" } ] }""", DisplayName = "Two matchers")]
[DataRow("""{ "rules": [ { "code": "a", "level": "boh", "status": [429] } ] }""", DisplayName = "Unknown level")]
[DataRow("""{ "rules": [ { "level": "throttle", "status": [429] } ] }""", DisplayName = "Missing code")]
[DataRow("""{ "rules": [ { "code": "a", "level": "throttle", "path": "([" } ] }""", DisplayName = "Invalid expression")]
[DataRow("""{ "rules": [ { "code": "a", "level": "throttle", "status": [429], "colore": "rosso" } ] }""", DisplayName = "Unknown key")]
[DataRow("""{ "rules": [], "emptyPages": { "code": "e", "level": "throttle", "consecutive": 1 } }""", DisplayName = "Threshold too low")]
public void InvalidRulesAreRefused(string json) =>
Assert.ThrowsExactly<InvalidDataException>(() => SignalRules.Parse(json));
[TestMethod]
public void ItalianLevelNamesAreAccepted()
{
var rules = SignalRules.Parse("""{ "rules": [ { "code": "a", "level": "Verifica", "path": "^/x" }, { "code": "b", "level": "rallentamento", "status": [503] } ] }""");
Assert.AreEqual(SignalLevel.Challenge, rules.Rules[0].Level);
Assert.AreEqual(SignalLevel.Throttle, rules.Rules[1].Level);
}
[TestMethod]
public void HostsAreClassifiedOnDomainBoundaries()
{
var ig = HostClassifier.Instagram;
Assert.AreEqual(HostKind.Site, ig.Classify("https://www.instagram.com/alice/"));
Assert.AreEqual(HostKind.Site, ig.Classify("https://instagram.com/"));
Assert.AreEqual(HostKind.Cdn, ig.Classify("https://scontent-mxp1-1.cdninstagram.com/v/t51/x.jpg?oe=1"));
Assert.AreEqual(HostKind.Cdn, ig.Classify("https://video.fmxp1-1.fna.fbcdn.net/o1/v.mp4"));
Assert.AreEqual(HostKind.Other, ig.Classify("https://evil-instagram.com/"));
Assert.AreEqual(HostKind.Other, ig.Classify("https://instagram.com.evil.example/"));
Assert.AreEqual(HostKind.Other, ig.Classify("about:blank"));
var local = new HostClassifier(["127.0.0.1:5000"], ["127.0.0.1:5001"]);
Assert.AreEqual(HostKind.Site, local.Classify("http://127.0.0.1:5000/a"));
Assert.AreEqual(HostKind.Cdn, local.Classify("http://127.0.0.1:5001/file.bin"));
Assert.AreEqual(HostKind.Other, local.Classify("http://127.0.0.1:5002/"));
}
[TestMethod]
public void AddressesLoseQueryFragmentAndCredentials()
{
Assert.AreEqual("https://www.example.org/a/b/", UrlSanitizer.Sanitize("https://user:pw@www.example.org/a/b/?token=x#frag").Url);
Assert.AreEqual("http://127.0.0.1:5000/verifica", UrlSanitizer.Sanitize("http://127.0.0.1:5000/verifica?next=/x").Url);
Assert.AreEqual("about:blank", UrlSanitizer.Sanitize("about:blank").Url);
Assert.AreEqual("data:", UrlSanitizer.Sanitize("data:text/plain;base64,c2VncmV0bw==").Url);
Assert.AreEqual(string.Empty, UrlSanitizer.Sanitize(null).Url);
}
private static (SignalDetector Detector, RecordingBreaker Breaker, VirtualClock Clock) Create()
{
var clock = new VirtualClock();
var breaker = new RecordingBreaker();
return (new SignalDetector(SignalRules.LoadTestSite(), breaker, clock), breaker, clock);
}
private static ResponseDescriptor Response(string path, int status, HostKind kind = HostKind.Site, bool mainDocument = false) =>
new("1", kind, "http://127.0.0.1:5000" + path, "127.0.0.1:5000", path, status, "application/json", mainDocument ? "Document" : "Fetch", mainDocument, DateTimeOffset.UnixEpoch);
private static NavigationDescriptor Navigation(string path) =>
new(HostKind.Site, "http://127.0.0.1:5000" + path, "127.0.0.1:5000", path, DateTimeOffset.UnixEpoch);
}