Self-test harness for the Lua gamemode/realm layer. Builds an in-memory filesystem of fake gamemodes, addons and manifests, then checks discovery, version constraints, dependency ordering, realm file filtering, include sandboxing, hooks, timers, serialization and content-manifest hashing. Exposes `rp_selftest` as a ConCmd that logs a pass/fail report.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RoleplayFramework.Lua;
namespace RoleplayFramework.Scripting;
/// <summary>
/// Tests for the gamemode/realm layer, run against an in-memory filesystem so nothing on disk is touched.
/// <c>rp_selftest</c> runs these plus the Lua runtime tests.
/// </summary>
public static class ScriptingSelfTest
{
public sealed record Result( string Name, bool Passed, string Detail );
const string GoodManifest = """
{ "id": "good", "title": "Good", "version": "1.0.0", "apiVersion": 1,
"entry": { "shared": "gamemode/sh_init.lua", "server": "gamemode/sv_init.lua", "client": "gamemode/cl_init.lua" } }
""";
static BaseFileSystem MakeFs()
{
var fs = FileSystem.CreateMemoryFileSystem();
fs.CreateDirectory( "lua/framework" );
fs.WriteAllText( "lua/framework/sh_core.lua", FileSystem.Mounted.ReadAllText( "lua/framework/sh_core.lua" ) );
Gamemode( fs, "good", GoodManifest, new()
{
["gamemode/sh_init.lua"] = "SHARED_LOADED = true\ninclude('gamemode/sh_extra.lua')\nfunction GM:Greet(name) return 'GM hello ' .. name end",
["gamemode/sh_extra.lua"] = "EXTRA_LOADED = REALM",
["gamemode/sv_init.lua"] = "SERVER_ONLY_SECRET = 42",
["gamemode/cl_init.lua"] = "CLIENT_LOADED = true",
["gamemode/sv_private.lua"] = "-- private server code",
} );
Gamemode( fs, "badapi", GoodManifest.Replace( "\"good\"", "\"badapi\"" ).Replace( "\"apiVersion\": 1", "\"apiVersion\": 99" ), new() );
Gamemode( fs, "nofields", "{ \"id\": \"nofields\" }", new() );
Gamemode( fs, "badpath", GoodManifest.Replace( "\"good\"", "\"badpath\"" ).Replace( "gamemode/sv_init.lua", "../../escape/sv_x.lua" ), new() );
Gamemode( fs, "wrongfolder", GoodManifest, new() );
Gamemode( fs, "cyc_a", Dep( "cyc_a", "cyc_b" ), Files() );
Gamemode( fs, "cyc_b", Dep( "cyc_b", "cyc_a" ), Files() );
Gamemode( fs, "child", Dep( "child", "good" ), new()
{
["gamemode/sh_init.lua"] = "CHILD_SAW_GOOD = SHARED_LOADED == true",
["gamemode/sv_init.lua"] = "",
["gamemode/cl_init.lua"] = "",
} );
Gamemode( fs, "orphan", Dep( "orphan", "missing_gm" ), Files() );
Gamemode( fs, "syntaxerr", GoodManifest.Replace( "\"good\"", "\"syntaxerr\"" ), new()
{
["gamemode/sh_init.lua"] = "local ok = true",
["gamemode/sv_init.lua"] = "local x = 1\nlocal y = = 2",
["gamemode/cl_init.lua"] = "",
} );
Gamemode( fs, "crossrealm", GoodManifest.Replace( "\"good\"", "\"crossrealm\"" ), new()
{
["gamemode/sh_init.lua"] = "",
["gamemode/sv_init.lua"] = "include('gamemode/cl_hud.lua')",
["gamemode/cl_init.lua"] = "include('gamemode/sv_secret.lua')",
["gamemode/cl_hud.lua"] = "",
["gamemode/sv_secret.lua"] = "",
} );
Gamemode( fs, "escape", GoodManifest.Replace( "\"good\"", "\"escape\"" ), new()
{
["gamemode/sh_init.lua"] = "include('../good/gamemode/sv_init.lua')",
["gamemode/sv_init.lua"] = "",
["gamemode/cl_init.lua"] = "",
} );
return fs;
}
static Dictionary<string, string> Files() => new()
{
["gamemode/sh_init.lua"] = "",
["gamemode/sv_init.lua"] = "",
["gamemode/cl_init.lua"] = "",
};
static string Dep( string id, string dep ) =>
GoodManifest.Replace( "\"good\"", $"\"{id}\"" ).Replace( "\"apiVersion\": 1,", $"\"apiVersion\": 1, \"dependencies\": [\"{dep}\"]," );
static void Gamemode( BaseFileSystem fs, string folder, string manifest, Dictionary<string, string> files )
{
var root = $"lua/gamemodes/{folder}";
fs.CreateDirectory( root + "/gamemode" );
fs.WriteAllText( root + "/gamemode.json", manifest );
foreach ( var (path, text) in files ) fs.WriteAllText( $"{root}/{path}", text );
}
public static List<Result> RunAll()
{
var results = new List<Result>();
void Check( string name, Func<(bool ok, string detail)> test )
{
try
{
var (ok, detail) = test();
results.Add( new Result( name, ok, detail ) );
}
catch ( Exception e )
{
results.Add( new Result( name, false, $"{e.GetType().Name}: {e.Message}" ) );
}
}
var fs = MakeFs();
var reg = GamemodeRegistry.Discover( fs, makeCurrent: false );
string Problems( string id ) => reg.Invalid.TryGetValue( id, out var p ) ? string.Join( "; ", p ) : "(accepted)";
Check( "valid gamemode accepted", () => (reg.Valid.ContainsKey( "good" ), string.Join( ",", reg.Valid.Keys )) );
Check( "incompatible apiVersion rejected", () => (Problems( "badapi" ).Contains( "'apiVersion' 99 is not supported" ), Problems( "badapi" )) );
Check( "missing fields rejected", () => (Problems( "nofields" ).Contains( "missing 'title'" ) && Problems( "nofields" ).Contains( "missing 'entry'" ), Problems( "nofields" )) );
Check( "path traversal in entry rejected", () => (Problems( "badpath" ).Contains( "'..' is not allowed" ), Problems( "badpath" )) );
Check( "id must match folder", () => (Problems( "wrongfolder" ).Contains( "must match its folder name" ), Problems( "wrongfolder" )) );
Check( "dependency cycle rejected", () => (Problems( "cyc_a" ).Contains( "cycle" ) && Problems( "cyc_b" ).Contains( "cycle" ), Problems( "cyc_a" )) );
Check( "missing dependency rejected", () => (Problems( "orphan" ).Contains( "missing_gm" ), Problems( "orphan" )) );
Check( "dependency load order", () =>
{
var order = string.Join( ",", reg.LoadOrder( "child" ).Select( m => m.Id ) );
return (order == "good,child", order);
} );
Check( "server realm loads shared + server files", () =>
{
var r = new LuaRealm( LuaRealmKind.Server, fs );
r.LoadFrameworkFiles();
r.LoadGamemode( reg, "good" );
var g = r.State.Globals;
bool ok = g.Get( "SHARED_LOADED" ).IsTruthy && g.Get( "EXTRA_LOADED" ).AsString == "server"
&& g.Get( "SERVER_ONLY_SECRET" ).Number == 42 && g.Get( "CLIENT_LOADED" ).IsNil;
return (ok, string.Join( ", ", r.LoadedFiles ));
} );
Check( "client realm never runs server files", () =>
{
var r = new LuaRealm( LuaRealmKind.Client, fs );
r.LoadFrameworkFiles();
r.LoadGamemode( reg, "good" );
var g = r.State.Globals;
bool ok = g.Get( "CLIENT_LOADED" ).IsTruthy && g.Get( "SERVER_ONLY_SECRET" ).IsNil && g.Get( "EXTRA_LOADED" ).AsString == "client"
&& !r.LoadedFiles.Any( f => f.Contains( "/sv_" ) );
return (ok, string.Join( ", ", r.LoadedFiles ));
} );
Check( "dependencies load first", () =>
{
var r = new LuaRealm( LuaRealmKind.Server, fs );
r.LoadFrameworkFiles();
r.LoadGamemode( reg, "child" );
return (r.State.Globals.Get( "CHILD_SAW_GOOD" ).IsTruthy, string.Join( ", ", r.LoadedFiles ));
} );
Check( "syntax error names file, line and realm", () =>
{
var errors = new List<ScriptError>();
Action<ScriptError> h = e => errors.Add( e );
LuaRealm.OnScriptError += h;
try
{
var r = new LuaRealm( LuaRealmKind.Server, fs );
r.LoadFrameworkFiles();
try { r.LoadGamemode( reg, "syntaxerr" ); return (false, "no error"); }
catch ( LuaSyntaxException e )
{
return (e.ChunkName == "gamemodes/syntaxerr/gamemode/sv_init.lua" && e.Line == 2 && r.Name == "server", e.Message);
}
}
finally { LuaRealm.OnScriptError -= h; }
} );
Check( "server cannot include client files", () => ExpectLoadError( fs, reg, "crossrealm", LuaRealmKind.Server, "in the server realm" ) );
Check( "client cannot include server files", () => ExpectLoadError( fs, reg, "crossrealm", LuaRealmKind.Client, "in the client realm" ) );
Check( "include cannot escape the gamemode folder", () => ExpectLoadError( fs, reg, "escape", LuaRealmKind.Server, "'..' is not allowed" ) );
Check( "unknown gamemode reports clearly", () => ExpectLoadError( fs, reg, "nope", LuaRealmKind.Server, "was not found" ) );
Check( "invalid gamemode cannot be loaded", () => ExpectLoadError( fs, reg, "badapi", LuaRealmKind.Server, "is invalid" ) );
Check( "hook.Run order, early return and GM fallback", () =>
{
var r = Loaded( fs, reg );
var res = r.State.DoString( """
local log = {}
hook.Add("Test", "a", function(x) log[#log+1] = "a" .. x end)
hook.Add("Test", "b", function(x) log[#log+1] = "b" .. x end)
hook.Run("Test", 1)
hook.Add("Stop", "first", function() return "stopped" end)
hook.Add("Stop", "second", function() log[#log+1] = "should not run" end)
local stop = hook.Run("Stop")
local gm = hook.Run("Greet", "bob")
hook.Remove("Test", "a")
hook.Run("Test", 2)
return table.concat(log, ","), stop, gm
""", "hooktest" );
var got = $"{res[0]}|{res[1]}|{res[2]}";
return (got == "a1,b1,b2|stopped|GM hello bob", got);
} );
Check( "a failing hook does not stop the others", () =>
{
int before = LuaRealm.RecentErrors.Count;
var r = Loaded( fs, reg );
var res = r.State.DoString( """
local ran = false
hook.Add("Boom", "bad", function() error("kaboom") end)
hook.Add("Boom", "good", function() ran = true end)
hook.Run("Boom")
return ran
""", "hookerr" );
var reported = LuaRealm.RecentErrors.Count > before && LuaRealm.RecentErrors[^1].Message.Contains( "kaboom" );
return (res[0].IsTruthy && reported, LuaRealm.RecentErrors.LastOrDefault().Message);
} );
Check( "Color / Vector / helpers", () =>
{
var r = Loaded( fs, reg );
var res = r.State.DoString( """
local c = Color(300, 20.4, -5)
local v = Vector(3, 4, 0) + Vector(0, 0, 12)
return tostring(c) .. "|" .. v:Length() .. "|" .. tostring(IsValid(c)) .. tostring(IsValid(nil)) .. tostring(IsValid({}))
.. "|" .. table.concat(string.Explode(",", "a,b,,c"), ";") .. "|" .. math.Round(2.567, 2)
""", "helpers" );
var got = res[0].AsString;
return (got == "Color(255, 20, 0, 255)|13|truefalsefalse|a;b;;c|2.57", got);
} );
Check( "timer.Simple / Create / Remove", () =>
{
var r = Loaded( fs, reg );
r.State.DoString( """
COUNT_SIMPLE, COUNT_REPEAT = 0, 0
timer.Simple(0, function() COUNT_SIMPLE = COUNT_SIMPLE + 1 end)
timer.Create("rep", 0.01, 3, function() COUNT_REPEAT = COUNT_REPEAT + 1 end)
timer.Create("gone", 0.01, 0, function() error("should have been removed") end)
timer.Remove("gone")
""", "timers" );
double t = Time.Now;
for ( int i = 1; i <= 6; i++ ) r.Tick( t + i );
var g = r.State.Globals;
var got = $"{g.Get( "COUNT_SIMPLE" )}/{g.Get( "COUNT_REPEAT" )}/{r.TimerCount}";
return (got == "1/3/0", got);
} );
Check( "net payload round trip", () =>
{
var L = new LuaState();
var v = L.DoString( "return { name = 'x\"y', list = {1, 2.5, -3}, flag = true, nested = { deep = { ok = 'yes' } } }", "p" )[0];
var text = LuaSerializer.Serialize( v );
var back = LuaSerializer.Deserialize( text );
var check = L.Call( L.Load( "local t = ...; return t.name .. '|' .. #t.list .. '|' .. t.list[2] .. '|' .. tostring(t.flag) .. '|' .. t.nested.deep.ok", "c" ), back )[0];
return (check.AsString == "x\"y|3|2.5|true|yes", check.AsString + " " + text);
} );
Check( "net payload rejects unsafe values", () =>
{
var L = new LuaState();
string Try( string expr )
{
try { LuaSerializer.Serialize( L.DoString( "return " + expr, "p" )[0] ); return "accepted"; }
catch ( LuaRuntimeException e ) { return e.Message; }
}
var fn = Try( "{ f = print }" );
var mixed = Try( "{ 1, 2, x = 3 }" );
var deep = Try( "{{{{{{{{{{}}}}}}}}}}" );
var big = Try( "string.rep('a', 3000)" );
bool ok = fn.Contains( "function" ) && mixed.Contains( "arrays or string-keyed" ) && deep.Contains( "deeper" ) && big.Contains( "longer than" );
return (ok, $"{fn} / {mixed} / {deep} / {big}");
} );
Check( "net payload parser rejects hostile input", () =>
{
string Try( string text )
{
try { LuaSerializer.Deserialize( text ); return "accepted"; }
catch ( FormatException e ) { return e.Message; }
}
var deep = Try( new string( '[', 50 ) + new string( ']', 50 ) );
var big = Try( "\"" + new string( 'a', 9000 ) + "\"" );
var junk = Try( "{\"a\":1} trailing" );
var bad = Try( "{\"a\": nan}" );
bool ok = deep.Contains( "deeper" ) && big.Contains( "too large" ) && junk.Contains( "trailing" ) && bad != "accepted";
return (ok, $"{deep} / {big} / {junk} / {bad}");
} );
Check( "content manifest excludes server files", () =>
{
var files = LuaContent.Build( fs, reg, "good" );
var paths = files.Select( f => f.Path ).ToList();
bool ok = paths.Contains( "lua/gamemodes/good/gamemode/cl_init.lua" ) && paths.Contains( "lua/gamemodes/good/gamemode/sh_extra.lua" )
&& paths.Contains( "lua/framework/sh_core.lua" ) && !paths.Any( p => p.Contains( "/sv_" ) );
return (ok, string.Join( ", ", paths ));
} );
Check( "content verification detects changes and refuses server files", () =>
{
var files = LuaContent.Build( fs, reg, "good" );
var okResult = LuaContent.Verify( fs, files );
var tampered = files.Select( f => new ContentFile { Path = f.Path, Hash = f.Hash } ).ToList();
tampered[0].Hash = new string( '0', 64 );
var changed = LuaContent.Verify( fs, tampered );
var sneaky = new List<ContentFile> { new() { Path = "lua/gamemodes/good/gamemode/sv_private.lua", Hash = new string( 'a', 64 ) } };
var refused = LuaContent.Verify( fs, sneaky );
var traversal = LuaContent.Verify( fs, new List<ContentFile> { new() { Path = "lua/../secret.lua", Hash = new string( 'a', 64 ) } } );
bool ok = okResult is null && changed?.Contains( "differ" ) == true && refused?.Contains( "server-only" ) == true && traversal?.Contains( "not allowed" ) == true;
return (ok, $"{okResult ?? "ok"} / {changed} / {refused} / {traversal}");
} );
AddAddonTests( fs, reg, Check );
return results;
}
// ------------------------------------------------------------ addons
static string AddonJson( string id, string extra = "" ) =>
$"{{ \"id\": \"{id}\", \"title\": \"{id}\", \"version\": \"1.0.0\", \"apiVersion\": 1{extra} }}";
static void Addon( BaseFileSystem fs, string folder, string manifest, Dictionary<string, string> files )
{
var root = $"lua/addons/{folder}";
fs.CreateDirectory( root );
fs.WriteAllText( root + "/addon.json", manifest );
foreach ( var (path, text) in files )
{
var full = $"{root}/{path}";
fs.CreateDirectory( full.Substring( 0, full.LastIndexOf( '/' ) ) );
fs.WriteAllText( full, text );
}
}
static void AddAddonTests( BaseFileSystem fs, GamemodeRegistry reg, Action<string, Func<(bool ok, string detail)>> Check )
{
Addon( fs, "a_lib", AddonJson( "a_lib" ).Replace( "1.0.0", "1.2.0" ), new() { ["sh_a.lua"] = "A_LOADED = true" } );
Addon( fs, "b_user", AddonJson( "b_user", ", \"dependencies\": { \"a_lib\": \">=1.0.0 <2.0.0\" }" ), new()
{
["sh_b.lua"] = "B_SAW_A = A_LOADED == true",
["sv_b.lua"] = "B_SERVER = true",
["cl_b.lua"] = "B_CLIENT = true",
["sv_zz_secret.lua"] = "-- server-only addon code",
} );
Addon( fs, "c_needs_v2", AddonJson( "c_needs_v2", ", \"dependencies\": { \"a_lib\": \"^2.0.0\" }" ), new() { ["sh_c.lua"] = "C_LOADED = true" } );
Addon( fs, "d_othergm", AddonJson( "d_othergm", ", \"gamemodes\": [ \"othergm\" ]" ), new() { ["sh_d.lua"] = "D_LOADED = true" } );
Addon( fs, "e_off", AddonJson( "e_off" ), new() { ["sh_e.lua"] = "E_LOADED = true", ["cl_e.lua"] = "" } );
Addon( fs, "f_needs_off", AddonJson( "f_needs_off", ", \"dependencies\": { \"e_off\": \"*\" }" ), new() { ["sh_f.lua"] = "" } );
Addon( fs, "g_cyc1", AddonJson( "g_cyc1", ", \"dependencies\": { \"g_cyc2\": \"\" }" ), new() );
Addon( fs, "g_cyc2", AddonJson( "g_cyc2", ", \"dependencies\": { \"g_cyc1\": \"\" }" ), new() );
Addon( fs, "h_badjson", "{ not json", new() );
Addon( fs, "h_badfields", "{ \"id\": \"h_badfields\", \"version\": \"one\", \"apiVersion\": 1, \"dependencies\": { \"a_lib\": \"about 1\" } }", new() );
Addon( fs, "i_broken", AddonJson( "i_broken" ), new() { ["sh_i.lua"] = "I_STARTED = true\nerror('boom')" } );
Addon( fs, "j_after_broken", AddonJson( "j_after_broken", ", \"dependencies\": { \"i_broken\": \"\" }" ), new() { ["sh_j.lua"] = "J_LOADED = true" } );
Addon( fs, "z_good", AddonJson( "z_good", ", \"gamemodes\": [ \"good\" ], \"entry\": { \"shared\": \"lua/sh_main.lua\" }" ), new()
{
["lua/sh_main.lua"] = "include('lua/sh_part.lua')\nfunction GM:Greet(name) return 'addon ' .. name end\nZ_FILES = #(file.Find('lua/*.lua'))",
["lua/sh_part.lua"] = "Z_PART = true",
["sh_ignored.lua"] = "Z_IGNORED = true", // entry given: other files only load through include
} );
Addon( fs, "_template", AddonJson( "_template" ), new() { ["sh_t.lua"] = "" } );
var chain = reg.LoadOrder( "child" ).Select( m => m.Id ).ToList(); // good, child
var addons = AddonRegistry.Resolve( fs, chain, new[] { "e_off" } );
string Status( string id ) => addons.All.TryGetValue( id, out var e ) ? $"{e.Status}: {e.Reason}" : "(missing)";
Check( "version constraints", () =>
{
bool ok = VersionConstraint.Satisfies( "1.2.0", ">=1.0.0 <2.0.0" ) && !VersionConstraint.Satisfies( "2.0.0", ">=1.0.0 <2.0.0" )
&& VersionConstraint.Satisfies( "1.9.3", "^1.2.0" ) && !VersionConstraint.Satisfies( "1.1.0", "^1.2.0" )
&& VersionConstraint.Satisfies( "1.2.9", "~1.2.0" ) && !VersionConstraint.Satisfies( "1.3.0", "~1.2.0" )
&& VersionConstraint.Satisfies( "1.0.0", "1.0.0" ) && !VersionConstraint.Satisfies( "1.0.1", "=1.0.0" )
&& VersionConstraint.Satisfies( "0.1.0", "*" ) && VersionConstraint.Satisfies( "0.1.0", "" )
&& VersionConstraint.Check( "about 1" ) is not null && VersionConstraint.Check( ">=1.0.0 <2.0.0" ) is null;
return (ok, "");
} );
Check( "addon statuses: active, disabled, incompatible, blocked, invalid", () =>
{
bool ok = Status( "a_lib" ).StartsWith( "Active" ) && Status( "b_user" ).StartsWith( "Active" ) && Status( "z_good" ).StartsWith( "Active" )
&& Status( "c_needs_v2" ).Contains( "needs 'a_lib' ^2.0.0, but 1.2.0" )
&& Status( "d_othergm" ).StartsWith( "Incompatible" )
&& Status( "e_off" ).StartsWith( "Disabled" )
&& Status( "f_needs_off" ).Contains( "which is disabled" )
&& Status( "g_cyc1" ).Contains( "cycle" ) && Status( "g_cyc2" ).Contains( "cycle" )
&& Status( "h_badjson" ).Contains( "not valid JSON" )
&& Status( "h_badfields" ).Contains( "missing 'title'" ) && Status( "h_badfields" ).Contains( "not semver" ) && Status( "h_badfields" ).Contains( "not a version constraint" )
&& !addons.All.ContainsKey( "_template" );
return (ok, string.Join( " | ", addons.All.Select( kv => $"{kv.Key}={kv.Value.Status}" ) ));
} );
Check( "addon load order: dependencies first, then alphabetical", () =>
{
var order = string.Join( ",", addons.LoadOrder.Select( m => m.Id ) );
return (order == "a_lib,b_user,i_broken,j_after_broken,z_good", order);
} );
Check( "addons load after the gamemode; a broken addon is skipped, not fatal", () =>
{
var errors = new List<ScriptError>();
Action<ScriptError> h = e => errors.Add( e );
LuaRealm.OnScriptError += h;
try
{
var r = new LuaRealm( LuaRealmKind.Server, fs );
LuaAddons.Register( r );
r.LoadFrameworkFiles();
r.LoadGamemode( reg, "child" );
r.LoadAddons( addons.LoadOrder );
var g = r.State.Globals;
var greet = r.Call( r.GM.Get( "Greet" ), r.GM, "x" )?[0].AsString;
var isLoaded = r.Call( ((LuaTable)g.Get( "addons" ).AsTable).Get( "IsLoaded" ), "b_user" )?[0].IsTruthy;
var brokenLoaded = r.Call( ((LuaTable)g.Get( "addons" ).AsTable).Get( "IsLoaded" ), "i_broken" )?[0].IsTruthy;
bool ok = g.Get( "B_SAW_A" ).IsTruthy && g.Get( "B_SERVER" ).IsTruthy && g.Get( "B_CLIENT" ).IsNil
&& g.Get( "I_STARTED" ).IsTruthy && g.Get( "J_LOADED" ).IsNil && g.Get( "Z_PART" ).IsTruthy && g.Get( "Z_IGNORED" ).IsNil
&& g.Get( "Z_FILES" ).Number == 2 && g.Get( "E_LOADED" ).IsNil && greet == "addon x" && isLoaded == true && brokenLoaded == false
&& errors.Any( e => e.Message.Contains( "Addon 'i_broken' failed to load" ) && e.Message.Contains( "boom" ) && e.Gamemode == "child+i_broken" )
&& errors.Any( e => e.Message.Contains( "'j_after_broken' skipped" ) );
return (ok, $"greet={greet}, errors: {string.Join( " / ", errors.Select( e => $"[{e.Gamemode}] {e.Message}" ) )}");
}
finally { LuaRealm.OnScriptError -= h; }
} );
Check( "client realm runs addon sh_/cl_ files only", () =>
{
var r = new LuaRealm( LuaRealmKind.Client, fs );
r.LoadFrameworkFiles();
r.LoadGamemode( reg, "child" );
r.LoadAddons( addons.LoadOrder.Where( m => m.Id is "a_lib" or "b_user" ) );
var g = r.State.Globals;
bool ok = g.Get( "B_CLIENT" ).IsTruthy && g.Get( "B_SERVER" ).IsNil && !r.LoadedFiles.Any( f => f.Contains( "/sv_" ) );
return (ok, string.Join( ", ", r.LoadedFiles ));
} );
Check( "content manifest carries active addons only, never sv_ files", () =>
{
var files = LuaContent.Build( fs, reg, "child", null, addons.LoadOrder );
var paths = files.Select( f => f.Path ).ToList();
bool ok = paths.Contains( "lua/addons/b_user/addon.json" ) && paths.Contains( "lua/addons/b_user/cl_b.lua" ) && paths.Contains( "lua/addons/z_good/lua/sh_part.lua" )
&& !paths.Any( p => p.Contains( "/sv_" ) ) && !paths.Any( p => p.Contains( "e_off" ) || p.Contains( "d_othergm" ) || p.Contains( "c_needs_v2" ) )
&& LuaContent.Verify( fs, files ) is null;
// A client given exactly that set resolves the same addons, in the same order, without any local config.
var clientFs = FileSystem.CreateMemoryFileSystem();
foreach ( var f in paths )
{
clientFs.CreateDirectory( f.Substring( 0, f.LastIndexOf( '/' ) ) );
clientFs.WriteAllText( f, fs.ReadAllText( f ) );
}
var clientReg = GamemodeRegistry.Discover( clientFs, makeCurrent: false );
var clientAddons = AddonRegistry.Resolve( clientFs, clientReg.LoadOrder( "child" )?.Select( m => m.Id ).ToList(), null );
var same = string.Join( ",", clientAddons.LoadOrder.Select( m => m.Id ) ) == string.Join( ",", addons.LoadOrder.Select( m => m.Id ) );
return (ok && same, $"client order {string.Join( ",", clientAddons.LoadOrder.Select( m => m.Id ) )}");
} );
}
static LuaRealm Loaded( BaseFileSystem fs, GamemodeRegistry reg )
{
var r = new LuaRealm( LuaRealmKind.Server, fs );
r.LoadFrameworkFiles();
r.LoadGamemode( reg, "good" );
return r;
}
static (bool, string) ExpectLoadError( BaseFileSystem fs, GamemodeRegistry reg, string id, LuaRealmKind kind, string expected )
{
var r = new LuaRealm( kind, fs );
r.LoadFrameworkFiles();
try
{
r.LoadGamemode( reg, id );
return (false, "loaded without error");
}
catch ( LuaException e )
{
return (e.Message.Contains( expected ), e.Message);
}
}
/// <summary>Runs these tests and the Lua runtime tests; returns a printable report.</summary>
public static string Report()
{
var start = DateTime.UtcNow;
var lua = Lua.Diagnostics.LuaSelfTest.RunAll();
var scripting = RunAll();
var failed = scripting.Where( r => !r.Passed ).ToList();
var sb = new StringBuilder();
sb.AppendLine( lua.Report );
sb.Append( $"Scripting layer: {scripting.Count - failed.Count}/{scripting.Count} passed" );
foreach ( var f in failed ) sb.Append( $"\n FAIL {f.Name}: {f.Detail}" );
sb.Append( $"\nTotal time {(DateTime.UtcNow - start).TotalMilliseconds:F0} ms" );
return sb.ToString();
}
[ConCmd( "rp_selftest", Help = "Run the Lua runtime and scripting-layer self-tests" )]
public static void Command()
{
foreach ( var line in Report().Split( '\n' ) ) Diagnostics.RpLog.Info( "selftest", line );
}
}