@rbxts/planck 0.2.5 → 0.3.0-alpha.2

package/src/__tests__/Scheduler.test.luau

@@ -0,0 +1,313 @@
+--!nonstrict
+local RunService = game:GetService("RunService")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local root = script.Parent.Parent
+
+local Phase = require(root.Phase)
+local Scheduler = require(root.Scheduler)
+local Pipeline = require(root.Pipeline)
+
+local JestGlobals = require(ReplicatedStorage.DevPackages.JestGlobals)
+
+local describe = JestGlobals.describe
+local expect = JestGlobals.expect
+local test = JestGlobals.test
+
+describe("scheduler", function()
+	describe("insert", function()
+		test("phase", function()
+			local myPhase = Phase.new("myPhase")
+			local myScheduler = Scheduler.new():insert(myPhase)
+
+			local orderedPhases =
+				myScheduler._defaultDependencyGraph:getOrderedList()
+			local mainIndex =
+				table.find(orderedPhases, myScheduler._defaultPhase)
+
+			expect(orderedPhases[mainIndex - 1]).toBe(myPhase)
+		end)
+
+		test("phase with event", function()
+			local myPhase = Phase.new("myPhase")
+
+			local myScheduler = Scheduler.new()
+				:insert(myPhase, RunService, "Heartbeat")
+
+			local identifier = `{RunService}@Heartbeat`
+			local dependencyGraph =
+				myScheduler._eventDependencyGraphs[identifier]
+
+			expect(dependencyGraph).toBeTruthy()
+			expect(myScheduler._connectedEvents[identifier]).toBeTruthy()
+
+			local orderedList = dependencyGraph:getOrderedList()
+			expect(orderedList[#orderedList]).toBe(myPhase)
+		end)
+
+		test("pipeline", function()
+			local myPhase = Phase.new()
+			local otherPhase = Phase.new()
+
+			local myPipeline =
+				Pipeline.new("myPipeline"):insert(myPhase):insert(otherPhase)
+
+			local myScheduler = Scheduler.new():insert(myPipeline)
+
+			local orderedDependencies =
+				myScheduler._defaultDependencyGraph:getOrderedList()
+			local mainIndex =
+				table.find(orderedDependencies, myScheduler._defaultPhase)
+
+			expect(orderedDependencies[mainIndex - 1]).toBe(myPipeline)
+
+			local orderedPhases = myPipeline.dependencyGraph:getOrderedList()
+			expect(orderedPhases[1]).toBe(myPhase)
+			expect(orderedPhases[2]).toBe(otherPhase)
+		end)
+
+		test("pipeline with event", function()
+			local myPhase = Phase.new()
+			local otherPhase = Phase.new()
+
+			local myPipeline =
+				Pipeline.new("myPipeline"):insert(myPhase):insert(otherPhase)
+
+			local myScheduler = Scheduler.new()
+				:insert(myPipeline, RunService, "Heartbeat")
+
+			local identifier = `{RunService}@Heartbeat`
+			local dependencyGraph =
+				myScheduler._eventDependencyGraphs[identifier]
+
+			expect(dependencyGraph).toBeTruthy()
+			expect(myScheduler._connectedEvents[identifier]).toBeTruthy()
+
+			local orderedList = dependencyGraph:getOrderedList()
+			expect(orderedList[1]).toBe(myPipeline)
+
+			local orderedPhases = myPipeline.dependencyGraph:getOrderedList()
+			expect(orderedPhases[1]).toBe(myPhase)
+			expect(orderedPhases[2]).toBe(otherPhase)
+		end)
+	end)
+
+	describe("insertAfter", function()
+		test("phase", function()
+			local phaseOne = Phase.new("phaseOne")
+			local phaseTwo = Phase.new("phaseTwo")
+			local phaseThree = Phase.new("phaseThree")
+
+			local myScheduler = Scheduler.new()
+				:insert(phaseOne)
+				:insert(phaseTwo)
+				:insertAfter(phaseThree, phaseOne)
+
+			local orderedPhases =
+				myScheduler._defaultDependencyGraph:getOrderedList()
+			local mainIndex =
+				table.find(orderedPhases, myScheduler._defaultPhase)
+
+			expect(orderedPhases[mainIndex - 3]).toBe(phaseOne)
+			expect(orderedPhases[mainIndex - 2]).toBe(phaseTwo)
+			expect(orderedPhases[mainIndex - 1]).toBe(phaseThree)
+		end)
+
+		test("pipeline", function()
+			local phaseOne = Phase.new("phaseOne")
+			local phaseTwo = Phase.new("phaseTwo")
+			local phaseThree = Phase.new("phaseThree")
+			local phaseFour = Phase.new("phaseFour")
+
+			local pipelineOne = Pipeline.new():insert(phaseOne):insert(phaseTwo)
+			local pipelineTwo = Pipeline.new():insert(phaseFour)
+			local pipelineThree = Pipeline.new():insert(phaseThree)
+
+			local myScheduler = Scheduler.new()
+				:insert(pipelineOne)
+				:insert(pipelineTwo)
+				:insertAfter(pipelineThree, pipelineOne)
+
+			local orderedDependencies =
+				myScheduler._defaultDependencyGraph:getOrderedList()
+			local mainIndex =
+				table.find(orderedDependencies, myScheduler._defaultPhase)
+
+			expect(orderedDependencies[mainIndex - 3]).toBe(pipelineOne)
+			expect(orderedDependencies[mainIndex - 2]).toBe(pipelineTwo)
+			expect(orderedDependencies[mainIndex - 1]).toBe(pipelineThree)
+		end)
+	end)
+
+	test("phase run condition", function()
+		expect.assertions(1)
+
+		local bool = true
+
+		local system = function(...)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler = Scheduler.new(1, 2, 3)
+			:insert(myPhase)
+			:addSystem(system, myPhase)
+			:addRunCondition(myPhase, function()
+				return bool
+			end)
+
+		myScheduler:runAll()
+
+		bool = false
+		myScheduler:runAll() -- Expect system to not run
+	end)
+
+	test("pipeline run condition", function()
+		expect.assertions(1)
+
+		local bool = true
+
+		local system = function(...)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local myPhase = Phase.new("myPhase")
+
+		local myPipeline = Pipeline.new():insert(myPhase)
+
+		local myScheduler = Scheduler.new(1, 2, 3)
+			:insert(myPipeline)
+			:addSystem(system, myPhase)
+			:addRunCondition(myPipeline, function()
+				return bool
+			end)
+
+		myScheduler:run(myPipeline)
+
+		bool = false
+		myScheduler:run(myPipeline) -- Expect system to not run
+	end)
+
+	test("getDeltaTime", function()
+		local deltaTime
+
+		local myScheduler = Scheduler.new()
+
+		local system = function()
+			deltaTime = myScheduler:getDeltaTime()
+		end
+
+		myScheduler:addSystem(system)
+		myScheduler:run(system)
+		expect(deltaTime).toEqual(0)
+		myScheduler:run(system)
+		expect(deltaTime).never.toEqual(0)
+	end)
+
+	test("custom system name", function()
+		expect.assertions(5)
+
+		local myScheduler = Scheduler.new()
+
+		local function mySystem() end
+
+		myScheduler:addSystem({
+			name = "CustomSystemName",
+			system = mySystem,
+		})
+
+		expect(myScheduler._systemInfo[mySystem].name).toBe("CustomSystemName")
+
+		local function anotherSystem() end
+		myScheduler:addSystem(anotherSystem)
+
+		expect(myScheduler._systemInfo[anotherSystem].name).toBe(
+			"anotherSystem"
+		)
+
+		local function replacementSystem() end
+		myScheduler:replaceSystem(mySystem, {
+			name = "ReplacedSystemName",
+			system = replacementSystem,
+		})
+
+		expect(myScheduler._systemInfo[replacementSystem].name).toBe(
+			"ReplacedSystemName"
+		)
+
+		local function finalSystem() end
+		myScheduler:replaceSystem(replacementSystem, finalSystem)
+
+		expect(myScheduler._systemInfo[finalSystem].name).toBe("finalSystem")
+
+		expect(myScheduler._systemInfo[replacementSystem]).toBeNil()
+	end)
+
+	describe("startup systems", function()
+		test("should run once", function()
+			expect.assertions(1)
+
+			local myScheduler = Scheduler.new(1, 2, 3):addSystem(function(...)
+				expect({ ... }).toEqual({ 1, 2, 3 })
+			end, Phase.Startup)
+
+			myScheduler:runAll()
+			myScheduler:runAll()
+		end)
+
+		test("run before events once", function()
+			expect.assertions(1)
+
+			local myPhase = Phase.new("myPhase")
+			local bindableEvent = Instance.new("BindableEvent")
+
+			Scheduler.new(1, 2, 3)
+				:addSystem(function(...)
+					expect({ ... }).toEqual({ 1, 2, 3 })
+				end, Phase.Startup)
+				:insert(myPhase, bindableEvent, bindableEvent.Event)
+
+			bindableEvent:Fire()
+			task.wait()
+			bindableEvent:Fire()
+			task.wait()
+		end)
+
+		test("each run exactly once", function(_, done)
+			expect.assertions(3)
+
+			local myPhase = Phase.new("myPhase")
+			local bindableEvent = Instance.new("BindableEvent")
+
+			local n = 0
+			local ranOnce = false
+
+			Scheduler.new()
+				:addSystem(function()
+					n += 1
+					expect(n).toEqual(1)
+				end, Phase.PreStartup)
+				:addSystem(function()
+					n += 1
+					expect(n).toEqual(2)
+				end, Phase.Startup)
+				:addSystem(function()
+					n += 1
+					expect(n).toEqual(3)
+				end, Phase.PostStartup)
+				:insert(myPhase, bindableEvent, bindableEvent.Event)
+				:addSystem(function()
+					if ranOnce then
+						done()
+					end
+
+					ranOnce = true
+				end, myPhase)
+
+			bindableEvent:Fire()
+			task.wait()
+			bindableEvent:Fire()
+			task.wait()
+		end)
+	end)
+end)

package/src/__tests__/conditions.test.luau

@@ -0,0 +1,147 @@
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local root = script.Parent.Parent
+
+local Scheduler = require(root.Scheduler)
+local conditions = require(root.conditions)
+
+local isNot = conditions.isNot
+local runOnce = conditions.runOnce
+local timePassed = conditions.timePassed
+local onEvent = conditions.onEvent
+
+local JestGlobals = require(ReplicatedStorage.DevPackages.JestGlobals)
+
+local describe = JestGlobals.describe
+local expect = JestGlobals.expect
+local test = JestGlobals.test
+
+describe("conditions", function()
+	test("isNot", function()
+		expect.assertions(1)
+		local function system()
+			expect("Planckton!!!").toEqual(expect.anything())
+		end
+
+		local bool = false
+
+		local function condition()
+			return bool
+		end
+
+		local myScheduler = Scheduler.new()
+			:addSystem(system)
+			:addRunCondition(system, isNot(condition))
+
+		myScheduler:runAll() -- Expect to run
+
+		bool = true
+		myScheduler:runAll() -- Expect to not run
+	end)
+
+	test("runOnce", function()
+		expect.assertions(1)
+		local function system()
+			expect(true).toBe(true)
+		end
+
+		local myScheduler =
+			Scheduler.new():addSystem(system):addRunCondition(system, runOnce())
+
+		myScheduler:runAll() -- Expect to run
+		myScheduler:runAll() -- Expect to not run
+	end)
+
+	test("timePassed", function()
+		expect.assertions(3)
+		local didRun = false
+		local firstRun = false
+
+		local function system()
+			if firstRun then
+				didRun = true
+			end
+
+			firstRun = true
+		end
+
+		local myScheduler = Scheduler.new()
+			:addSystem(system)
+			:addRunCondition(system, timePassed(1))
+
+		myScheduler:runAll()
+		expect(didRun).toBe(false)
+		task.wait(0.5)
+
+		myScheduler:runAll()
+		expect(didRun).toBe(false)
+		task.wait(0.5)
+
+		myScheduler:runAll()
+		expect(didRun).toBe(true)
+	end)
+
+	test("onEvent", function()
+		expect.assertions(4)
+		local didRun = false
+		local bindableEvent = Instance.new("BindableEvent")
+
+		local function system()
+			didRun = true
+		end
+
+		local myScheduler = Scheduler.new():addSystem(system):addRunCondition(
+			system,
+			onEvent(bindableEvent, bindableEvent.Event)
+		)
+
+		myScheduler:runAll()
+		expect(didRun).toBe(false)
+		bindableEvent:Fire()
+		task.wait()
+
+		myScheduler:runAll()
+		expect(didRun).toBe(true)
+		didRun = false
+
+		myScheduler:runAll()
+		expect(didRun).toBe(false)
+		bindableEvent:Fire()
+		task.wait()
+
+		myScheduler:runAll()
+		expect(didRun).toBe(true)
+	end)
+
+	test("onEvent in SystemTable", function()
+		expect.assertions(4)
+		local didRun = false
+		local bindableEvent = Instance.new("BindableEvent")
+
+		local function system()
+			didRun = true
+		end
+
+		local myScheduler = Scheduler.new():addSystem({
+			system = system,
+			runConditions = { onEvent(bindableEvent, bindableEvent.Event) },
+		})
+
+		myScheduler:runAll()
+		expect(didRun).toBe(false)
+		bindableEvent:Fire()
+		task.wait()
+
+		myScheduler:runAll()
+		expect(didRun).toBe(true)
+		didRun = false
+
+		myScheduler:runAll()
+		expect(didRun).toBe(false)
+		bindableEvent:Fire()
+		task.wait()
+
+		myScheduler:runAll()
+		expect(didRun).toBe(true)
+	end)
+end)

package/src/__tests__/hooks.test.luau

@@ -0,0 +1,54 @@
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local root = script.Parent.Parent
+
+local Phase = require(root.Phase)
+local Scheduler = require(root.Scheduler)
+
+local JestGlobals = require(ReplicatedStorage.DevPackages.JestGlobals)
+
+local describe = JestGlobals.describe
+local expect = JestGlobals.expect
+local test = JestGlobals.test
+
+describe("topoRuntime", function()
+	test("useDeltaTime", function()
+		local matterHooks =
+			require(ReplicatedStorage.Packages.PlanckMatterHooks)
+		local useDeltaTime = matterHooks.useDeltaTime
+		expect.assertions(1)
+
+		local plugin = matterHooks.Plugin.new()
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler = Scheduler.new(1, 2, 3)
+			:addPlugin(plugin)
+			:insert(myPhase)
+			:addSystem(function()
+				expect(useDeltaTime()).toBeTruthy()
+			end, myPhase)
+
+		myScheduler:runAll()
+	end)
+
+	test("useThrottle", function()
+		local matterHooks =
+			require(ReplicatedStorage.Packages.PlanckMatterHooks)
+		local useThrottle = matterHooks.useThrottle
+		expect.assertions(1)
+
+		local plugin = matterHooks.Plugin.new()
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler = Scheduler.new(1, 2, 3)
+			:addPlugin(plugin)
+			:insert(myPhase)
+			:addSystem(function()
+				if useThrottle(1) then
+					expect(true).toBe(true)
+				end
+			end, myPhase)
+
+		myScheduler:runAll()
+	end)
+end)

package/src/__tests__/systems.test.luau

@@ -0,0 +1,192 @@
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local root = script.Parent.Parent
+
+local Phase = require(root.Phase)
+local Scheduler = require(root.Scheduler)
+
+local JestGlobals = require(ReplicatedStorage.DevPackages.JestGlobals)
+
+local describe = JestGlobals.describe
+local expect = JestGlobals.expect
+local test = JestGlobals.test
+
+describe("systems", function()
+	test("add", function()
+		expect.assertions(1)
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler = Scheduler.new(1, 2, 3)
+			:insert(myPhase)
+			:addSystem(function(...)
+				expect({ ... }).toEqual({ 1, 2, 3 })
+			end, myPhase)
+
+		myScheduler:runAll()
+	end)
+
+	test("edit", function()
+		expect.assertions(2)
+
+		local function systemA(...)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler =
+			Scheduler.new(1, 2, 3):insert(myPhase):addSystem(systemA, myPhase)
+
+		myScheduler:runAll()
+
+		local otherPhase = Phase.new()
+		myScheduler:insert(otherPhase)
+
+		myScheduler:editSystem(systemA, otherPhase)
+		myScheduler:run(otherPhase)
+
+		-- Expect nothing to run here
+		myScheduler:run(myPhase)
+	end)
+
+	test("remove", function()
+		expect.assertions(1)
+
+		local function systemA(...)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler =
+			Scheduler.new(1, 2, 3):insert(myPhase):addSystem(systemA, myPhase)
+
+		myScheduler:runAll()
+
+		myScheduler:removeSystem(systemA)
+		myScheduler:runAll() -- Expect nothing here
+	end)
+
+	test("replace", function()
+		expect.assertions(3)
+
+		local function systemA(...)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local function systemB(...)
+			-- FUTURE: Use Jest.spyOn
+			expect(true).toBe(true)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler =
+			Scheduler.new(1, 2, 3):insert(myPhase):addSystem(systemA, myPhase)
+
+		myScheduler:runAll()
+
+		myScheduler:replaceSystem(systemA, systemB)
+		myScheduler:runAll()
+	end)
+
+	test("system table", function()
+		expect.assertions(1)
+
+		local myPhase = Phase.new("myPhase")
+
+		local system = {
+			system = function(...)
+				expect({ ... }).toEqual({ 1, 2, 3 })
+			end,
+			phase = myPhase,
+		}
+
+		local myScheduler =
+			Scheduler.new(1, 2, 3):insert(myPhase):addSystem(system)
+
+		myScheduler:run(myPhase)
+	end)
+
+	test("run condition", function()
+		expect.assertions(1)
+
+		local bool = true
+
+		local system = function(...)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler = Scheduler.new(1, 2, 3)
+			:insert(myPhase)
+			:addSystem(system, myPhase)
+			:addRunCondition(system, function()
+				return bool
+			end)
+
+		myScheduler:runAll()
+
+		bool = false
+		myScheduler:runAll() -- Expect system to not run
+	end)
+
+	test("multiple run conditions", function()
+		expect.assertions(1)
+
+		local firstCondition = true
+		local secondCondition = true
+
+		local system = function(...)
+			expect({ ... }).toEqual({ 1, 2, 3 })
+		end
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler = Scheduler.new(1, 2, 3)
+			:insert(myPhase)
+			:addSystem(system, myPhase)
+			:addRunCondition(system, function()
+				return firstCondition
+			end)
+			:addRunCondition(system, function()
+				return secondCondition
+			end)
+
+		firstCondition = false
+		myScheduler:runAll()
+
+		firstCondition = true
+		secondCondition = false
+		myScheduler:runAll()
+
+		firstCondition = false
+		secondCondition = false
+		myScheduler:runAll()
+
+		firstCondition = true
+		secondCondition = true
+		myScheduler:runAll() -- Expect to run
+	end)
+
+	test("yield", function()
+		expect.assertions(1)
+
+		local system = function()
+			wait(5)
+		end
+
+		local myPhase = Phase.new("myPhase")
+		local myScheduler =
+			Scheduler.new(1, 2, 3):insert(myPhase):addSystem(system, myPhase)
+
+		local err;
+
+		(myScheduler :: any):_addHook(
+			(myScheduler :: any).Hooks.SystemError,
+			function(args)
+				err = args.error
+			end
+		)
+
+		myScheduler:runAll()
+		expect(err).toEqual(expect.stringContaining("System yielded"))
+	end)
+end)