sporel/sporel-lib-core.composition-test
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
68a0932f8b483f58fe2146c49b6a81000b80303d
sporel-lib-core.composition…/init.lua
Axel Meyer 68a0932f8b test: assert template_of getter behavior + bump to v0.3.0 
Bump composition dep to 0.3.0 and add 3 assertions covering the new
getter: round-trip template-id on composition.create, loud-error on
nil arg with message-pattern match, nil on raw entity.create handle.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-06-14 11:57:31 +02:00

222 lines
9.6 KiB
Lua
Raw Blame History

-- lib-core.composition-test — Phase A.1 + B.1 + C.0
-- 26 assertions: 4 define_template + 4 create + 3 list_by_* + 2 destroy + 1 list_templates
-- + 8 B.1 (set_tag round-trip + container-block validation) + 1 slots regression
-- + 3 C.0 (template_of getter: round-trip, nil-arg loud-error, raw-entity nil).
-- Pattern follows P.2.4 Test-Module-Pattern; TAP output via engine.test.*
local composition = require("lib-core.composition")
local T = engine.test
local M = {}
function M.run_tests(ctx)
-- ----------------------------------------------------------------
-- define_template (4)
-- ----------------------------------------------------------------
-- Happy path: define + retrieve via list_templates
composition.define_template{
id = "sign",
properties = {
sprite_path = "sprites/sign.png",
text = "default text",
position = {x = 0, y = 0},
},
tags = {"renderable"},
}
local templates_after_define = composition.list_templates()
local found_sign = false
for _, id in ipairs(templates_after_define) do
if id == "sign" then found_sign = true; break end
end
T.assert(found_sign, "define_template 'sign' registers in list_templates")
-- Loud-error on missing id
local ok_missing = pcall(composition.define_template, { properties = {} })
T.assert(not ok_missing, "define_template loud-errors on missing id")
-- Loud-error on duplicate id (sign already defined above)
local ok_dup = pcall(composition.define_template, { id = "sign", properties = {} })
T.assert(not ok_dup, "define_template loud-errors on duplicate id")
-- Loud-error on deferred slots-block (Phase D)
local ok_slots = pcall(composition.define_template, {
id = "sword",
slots = { blade = {} },
})
T.assert(not ok_slots, "define_template loud-errors on 'slots' block (Phase D trigger)")
-- ----------------------------------------------------------------
-- create (4)
-- ----------------------------------------------------------------
-- Happy path: create returns a non-nil entity that carries template
-- properties + per-instance overrides
local sign1 = composition.create{
template = "sign",
properties = {
position = {x = 144, y = 200},
text = "Hello",
},
}
T.assert(sign1 ~= nil, "create returns a non-nil entity handle")
T.equals(sign1:get_property("text"), "Hello",
"create override sets text-property")
T.equals(sign1:get_property("position.x"), 144,
"create flattens nested position into position.x")
-- Template-default-property survives when override doesn't touch it
T.equals(sign1:get_property("sprite_path"), "sprites/sign.png",
"create preserves template default for sprite_path")
-- ----------------------------------------------------------------
-- list_by_template + list_by_tag (3)
-- ----------------------------------------------------------------
-- Single instance
local by_tpl = composition.list_by_template("sign")
T.assert(#by_tpl == 1, "list_by_template returns 1 entity after 1 create")
-- Tag-Index
local by_tag = composition.list_by_tag("renderable")
T.assert(#by_tag == 1, "list_by_tag returns 1 entity for 'renderable'")
-- Unknown template / tag → empty
local empty_tpl = composition.list_by_template("nonexistent")
T.assert(#empty_tpl == 0, "list_by_template empty for unknown template")
-- ----------------------------------------------------------------
-- destroy (2)
-- ----------------------------------------------------------------
-- Create a second instance, then destroy it, indexes shrink
local sign2 = composition.create{
template = "sign",
properties = { position = {x = 50, y = 50}, text = "T2" },
}
T.assert(#composition.list_by_template("sign") == 2,
"list_by_template grows to 2 after second create")
composition.destroy(sign2)
T.assert(#composition.list_by_template("sign") == 1,
"destroy shrinks template-index back to 1")
-- ----------------------------------------------------------------
-- list_templates (1)
-- ----------------------------------------------------------------
-- list_templates is non-empty after define
T.assert(#composition.list_templates() >= 1,
"list_templates returns at least 1 entry after define_template")
-- ================================================================
-- B.1 — set_tag + container-block validation (8)
-- ================================================================
-- Need a live entity to test set_tag against.
local tagtest_entity = composition.create{ template = "sign" }
-- 1. set_tag(e, "foo", true) → list_by_tag("foo") contains e.
composition.set_tag(tagtest_entity, "foo", true)
local foo_list_after_add = composition.list_by_tag("foo")
local found_in_foo = false
for _, e in ipairs(foo_list_after_add) do
if e == tagtest_entity then found_in_foo = true; break end
end
T.assert(found_in_foo, "set_tag(e,'foo',true) adds e to list_by_tag('foo')")
-- 2. set_tag(e, "foo", false) → list_by_tag("foo") does not contain e.
composition.set_tag(tagtest_entity, "foo", false)
local foo_list_after_remove = composition.list_by_tag("foo")
local still_in_foo = false
for _, e in ipairs(foo_list_after_remove) do
if e == tagtest_entity then still_in_foo = true; break end
end
T.assert(not still_in_foo, "set_tag(e,'foo',false) removes e from list_by_tag('foo')")
-- 3. set_tag idempotent — double true and double false must not error
-- and must not duplicate / extra-remove entries.
composition.set_tag(tagtest_entity, "bar", true)
composition.set_tag(tagtest_entity, "bar", true) -- second call: idempotent
local bar_list = composition.list_by_tag("bar")
local bar_count = 0
for _, e in ipairs(bar_list) do
if e == tagtest_entity then bar_count = bar_count + 1 end
end
T.equals(bar_count, 1, "set_tag idempotent: double-true does not duplicate in index")
composition.set_tag(tagtest_entity, "bar", false)
composition.set_tag(tagtest_entity, "bar", false) -- second call: idempotent
local bar_list_after = composition.list_by_tag("bar")
local bar_count_after = 0
for _, e in ipairs(bar_list_after) do
if e == tagtest_entity then bar_count_after = bar_count_after + 1 end
end
T.equals(bar_count_after, 0, "set_tag idempotent: double-false does not error or leave stale entry")
-- 4. set_tag on a foreign (non-composition) entity → Loud-Error.
local alien = entity.create()
local ok_alien = pcall(composition.set_tag, alien, "any", true)
T.assert(not ok_alien, "set_tag loud-errors on entity not created by composition")
-- 5. define_template with container={kind="list"} → accepted (no error).
local ok_container_list = pcall(composition.define_template, {
id = "backpack",
properties = {
sprite_atlas = "sprites/items.png",
sprite_uv = "0 0 32 32",
position = {x = 0, y = 0},
},
tags = {"renderable"},
container = { kind = "list" },
})
T.assert(ok_container_list, "define_template accepts container={kind='list'}")
-- 6. define_template with container={kind="grid"} → Loud-Error.
local ok_container_grid = pcall(composition.define_template, {
id = "grid_bag",
container = { kind = "grid" },
})
T.assert(not ok_container_grid, "define_template loud-errors on container={kind='grid'}")
-- 7. define_template with container={kind="list", weight_max=10} → Loud-Error
-- (unimplemented constraint field declared).
local ok_weight_max = pcall(composition.define_template, {
id = "heavy_bag",
container = { kind = "list", weight_max = 10 },
})
T.assert(not ok_weight_max,
"define_template loud-errors on container with unimplemented constraint weight_max")
-- 8. define_template with slots={...} → still Loud-Error (Phase D, regression).
local ok_slots_regression = pcall(composition.define_template, {
id = "composite_sword",
slots = { blade = {} },
})
T.assert(not ok_slots_regression,
"define_template still loud-errors on 'slots' block (Phase D regression)")
-- ================================================================
-- C.0 — template_of getter (3)
-- ================================================================
-- 1. composition.create returns entity whose template_of returns its template-id.
local template_of_target = composition.create{ template = "sign" }
T.equals(composition.template_of(template_of_target), "sign",
"template_of returns template-id for composition-created entity")
-- 2. template_of(nil) loud-errors with message matching "composition.template_of.*entity".
local ok_nil, err_nil = pcall(composition.template_of, nil)
T.assert(not ok_nil and type(err_nil) == "string"
and string.find(err_nil, "composition%.template_of") ~= nil
and string.find(err_nil, "entity") ~= nil,
"template_of(nil) loud-errors with message matching 'composition.template_of.*entity'")
-- 3. Raw engine.entity.create() entity (no composition) → template_of returns nil (no error).
local raw_alien = entity.create()
T.equals(composition.template_of(raw_alien), nil,
"template_of returns nil for raw entity.create() handle (not composition-managed)")
end
return M
Reference in New Issue View Git Blame Copy Permalink