From b9bc52385c97d2fbd230de41f2c86f2fcf7fd574 Mon Sep 17 00:00:00 2001 From: Khietsly Tristan Date: Wed, 11 Feb 2026 14:42:04 +0700 Subject: [PATCH] tests --- test/api.spec.luau | 32 ++++++++ test/buffer.spec.luau | 123 +++++++++++++++++++++++++++++++ test/client.spec.luau | 34 +++++++++ test/init.spec.luau | 166 ------------------------------------------ test/server.spec.luau | 34 +++++++++ 5 files changed, 223 insertions(+), 166 deletions(-) create mode 100644 test/api.spec.luau create mode 100644 test/buffer.spec.luau create mode 100644 test/client.spec.luau delete mode 100644 test/init.spec.luau create mode 100644 test/server.spec.luau diff --git a/test/api.spec.luau b/test/api.spec.luau new file mode 100644 index 0000000..b7aab23 --- /dev/null +++ b/test/api.spec.luau @@ -0,0 +1,32 @@ +--!nocheck + +return function() + local ReplicatedStorage = game:GetService("ReplicatedStorage") + local RunService = game:GetService("RunService") + + local WarpModule = ReplicatedStorage:WaitForChild("Warp") + local Warp = require(WarpModule) + + describe("public api", function() + it("exports Client/Server factories and Buffer", function() + expect(type(Warp)).to.equal("table") + expect(type(Warp.Client)).to.equal("function") + expect(type(Warp.Server)).to.equal("function") + expect(type(Warp.Buffer)).to.equal("table") + end) + + it("creates RemoteEvent/RemoteFunction under the module (server only)", function() + if not RunService:IsServer() then + return + end + + local ev = WarpModule:FindFirstChild("Event") + local fn = WarpModule:FindFirstChild("Function") + + expect(ev).to.be.ok() + expect(fn).to.be.ok() + expect((ev :: Instance):IsA("RemoteEvent")).to.equal(true) + expect((fn :: Instance):IsA("RemoteFunction")).to.equal(true) + end) + end) +end \ No newline at end of file diff --git a/test/buffer.spec.luau b/test/buffer.spec.luau new file mode 100644 index 0000000..7a29056 --- /dev/null +++ b/test/buffer.spec.luau @@ -0,0 +1,123 @@ +--!nocheck + +return function() + local ReplicatedStorage = game:GetService("ReplicatedStorage") + local WarpModule = ReplicatedStorage:WaitForChild("Warp") + local Warp = require(WarpModule) + + local function roundTrip(Buffer: any, value: T): T + local buf, refs = Buffer.write(value) + local decoded = Buffer.read(buf, refs) + return decoded + end + + describe("Warp.Buffer", function() + local Buffer = Warp.Buffer + + it("round-trips tagged primitives (write/read)", function() + expect(roundTrip(Buffer, true)).to.equal(true) + expect(roundTrip(Buffer, false)).to.equal(false) + expect(roundTrip(Buffer, 0)).to.equal(0) + expect(roundTrip(Buffer, 127)).to.equal(127) + expect(roundTrip(Buffer, 128)).to.equal(128) + expect(roundTrip(Buffer, -1)).to.equal(-1) + expect(roundTrip(Buffer, -32)).to.equal(-32) + expect(roundTrip(Buffer, -33)).to.equal(-33) + expect(roundTrip(Buffer, 255)).to.equal(255) + expect(roundTrip(Buffer, 256)).to.equal(256) + expect(roundTrip(Buffer, "hi")).to.equal("hi") + expect(roundTrip(Buffer, string.rep("a", 40))).to.equal(string.rep("a", 40)) + end) + + it("round-trips arrays and maps (write/read)", function() + local arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } + local decodedArr = roundTrip(Buffer, arr) + expect(type(decodedArr)).to.equal("table") + expect(#decodedArr).to.equal(#arr) + for i = 1, #arr do + expect(decodedArr[i]).to.equal(arr[i]) + end + + local map = { a = 1, b = true, c = "ok" } + local decodedMap = roundTrip(Buffer, map) + expect(type(decodedMap)).to.equal("table") + expect(decodedMap.a).to.equal(1) + expect(decodedMap.b).to.equal(true) + expect(decodedMap.c).to.equal("ok") + end) + + it("round-trips Instances through refs (write/read)", function() + local inst = Instance.new("Folder") + inst.Name = "WarpBufferTestFolder" + + local buf, refs = Buffer.write(inst) + expect(type(buf)).to.equal("buffer") + expect(type(refs)).to.equal("table") + expect((refs :: { any })[1]).to.equal(inst) + + local decodedWithRefs = Buffer.read(buf, refs) + expect(decodedWithRefs).to.equal(inst) + + local decodedWithoutRefs = Buffer.read(buf) + expect(decodedWithoutRefs).to.equal(nil) + end) + + it("can pack multiple tagged values and read them back (readAll)", function() + local w = Buffer.createWriter() + Buffer.pack(w, "a") + Buffer.pack(w, 123) + Buffer.pack(w, { 1, 2, 3, 4 }) + + local buf, refs = Buffer.buildWithRefs(w) + local values = Buffer.readAll(buf, refs) + expect(#values).to.equal(3) + expect(values[1]).to.equal("a") + expect(values[2]).to.equal(123) + expect(type(values[3])).to.equal("table") + expect(#(values[3] :: { any })).to.equal(4) + end) + + it("encodes/decodes varUInt", function() + local b = buffer.create(16) + local endOffset = Buffer.writeVarUInt(b, 0, 300) + local v, newOffset = Buffer.readVarUInt(b, 0) + expect(v).to.equal(300) + expect(newOffset).to.equal(endOffset) + end) + + it("encodes/decodes event batches (writeEvents/readEvents), with and without schemas", function() + local S = Buffer.Schema + local schemas = { + MyRemote = S.struct({ + count = S.u8, + msg = S.string, + }), + } + + local payload = { + count = 7, + msg = "hello", + } + + local events = { + { "MyRemote", { payload } }, + { "OtherRemote", { 1, 2 } }, + } + + local w = Buffer.createWriter() + Buffer.writeEvents(w, events, schemas) + local buf, refs = Buffer.buildWithRefs(w) + + local decoded = Buffer.readEvents(buf, refs, schemas) + expect(#decoded).to.equal(2) + + expect(decoded[1][1]).to.equal("MyRemote") + expect(decoded[1][2][1].count).to.equal(7) + expect(decoded[1][2][1].msg).to.equal("hello") + + expect(decoded[2][1]).to.equal("OtherRemote") + expect(decoded[2][2][1]).to.equal(1) + expect(decoded[2][2][2]).to.equal(2) + end) + end) +end \ No newline at end of file diff --git a/test/client.spec.luau b/test/client.spec.luau new file mode 100644 index 0000000..d352bf8 --- /dev/null +++ b/test/client.spec.luau @@ -0,0 +1,34 @@ +--!nocheck + +return function() + local ReplicatedStorage = game:GetService("ReplicatedStorage") + local WarpModule = ReplicatedStorage:WaitForChild("Warp") + local Warp = require(WarpModule) + + describe("Warp.Client()", function() + local Client = Warp.Client() + + it("returns a module with expected functions", function() + expect(type(Client)).to.equal("table") + expect(type(Client.Connect)).to.equal("function") + expect(type(Client.Once)).to.equal("function") + expect(type(Client.Wait)).to.equal("function") + expect(type(Client.DisconnectAll)).to.equal("function") + expect(type(Client.Destroy)).to.equal("function") + expect(type(Client.Fire)).to.equal("function") + expect(type(Client.Invoke)).to.equal("function") + expect(type(Client.useSchema)).to.equal("function") + expect(type(Client.Schema)).to.equal("table") + end) + + it("Connect returns a connection that can disconnect", function() + local conn = Client.Connect("_test_connect", function() end) + expect(conn).to.be.ok() + expect(conn.Connected).to.equal(true) + expect(type(conn.Disconnect)).to.equal("function") + + conn:Disconnect() + expect(conn.Connected).to.equal(false) + end) + end) +end \ No newline at end of file diff --git a/test/init.spec.luau b/test/init.spec.luau deleted file mode 100644 index 68ef833..0000000 --- a/test/init.spec.luau +++ /dev/null @@ -1,166 +0,0 @@ -return function() - local Warp = require(game:GetService("ReplicatedStorage").Warp) - - describe("Warp.Server", function() - it("should be able to create a new server event", function() - local test = Warp.Server("Test") - expect(test).to.be.ok() - end) - - it("should be able to create a new server event with ratelimit configuration", function() - local test = Warp.Server("Test", { - maxEntrance = 10, - interval = 1, - }) - expect(test).to.be.ok() - end) - end) - - describe("Warp.fromServerArray", function() - it("should be able to create a new server event with arrays", function() - local test = Warp.fromServerArray({ - "Test1", - "Test2", - }) - expect(test).to.be.ok() - expect(test.Test1).to.be.ok() - expect(test.Test2).to.be.ok() - end) - - it("should be able to create a new server event with arrays & ratelimit configuration", function() - local test = Warp.fromServerArray({ - "Test1", - "Test2", - ["Test3"] = { - maxEntrance = 10, - interval = 0.75, - }, - }) - expect(test).to.be.ok() - expect(test.Test1).to.be.ok() - expect(test.Test2).to.be.ok() - expect(test.Test3).to.be.ok() - end) - end) - - describe("Event.Connect", function() - it("should be able to connect the event", function() - local test = Warp.Server("Test") - test:Connect(function() end) - expect(test.IsConnected).to.be.ok() - end) - end) - - describe("Multi Event.Connect", function() - it("should be able to multiple connect the event", function() - local test = Warp.Server("Test") - test:Connect(function() end) - test:Connect(function() end) - expect(test.IsConnected).to.be.ok() - end) - end) - - describe("Event.DisconnectAll", function() - it("should be able to disconnect all the event connections", function() - local test = Warp.Server("Test") - test:DisconnectAll() - expect(#test.fn).to.equal(0) - end) - end) - - describe("Event.Disconnect", function() - it("should be able to disconnect the event connection", function() - local test = Warp.Server("Test") - local connection = test:Connect(function() end) - expect(test:Disconnect(connection)).to.be.ok() - end) - end) - - describe("Warp.Signal", function() - it("should be able to create a new signal", function() - local test = Warp.Signal("Test") - expect(test).to.be.ok() - end) - end) - - describe("Warp.fromSignalArray", function() - it("should be able to create a new signal with arrays", function() - local test = Warp.fromSignalArray({ - "Test1", - "Test2" - }) - expect(test).to.be.ok() - expect(test.Test1).to.be.ok() - expect(test.Test2).to.be.ok() - end) - end) - - describe("Signal.Connect", function() - it("should be able to connect the signal", function() - local test = Warp.Signal("Test") - expect(test:Connect(function() end)).to.be.ok() - test:DisconnectAll() - end) - end) - - describe("Multi Signal.Connect", function() - it("should be able to multiple connect the signal", function() - local test = Warp.Signal("Test") - expect(test:Connect(function() end)).to.be.ok() - expect(test:Connect(function() end)).to.be.ok() - test:DisconnectAll() - end) - end) - - describe("Signal.Fire", function() - it("should be able to fire the signal", function() - local test = Warp.Signal("Test") - test:Once(function(arg) - expect(arg).to.equal("hello world!") - end) - test:Fire("hello world!") - end) - end) - - describe("Signal.Invoke", function() - it("should be able to invoke the signal", function() - local test = Warp.Signal("Test") - local connection = test:Connect(function(arg) - if arg ~= "test" then - return - end - return "hello world!" - end) - local receive = test:Invoke(connection, "test") - expect(receive).to.equal("hello world!") - end) - end) - - describe("Signal.InvokeTo", function() - it("should be able to invoke to a signal", function() - local test = Warp.Signal("Test") - local test2 = Warp.Signal("Test2") - local connection = test2:Connect(function(arg) - if arg ~= "test" then - return - end - return "hello world!" - end) - local receive = test:InvokeTo("Test2", connection, "test") - expect(receive).to.equal("hello world!") - end) - end) - - describe("Signal.Wait", function() - it("should be able to wait for the signal", function() - local test = Warp.Signal("Test") - test:Connect(function() end) - task.spawn(function() - local time = test:Wait() - expect(time).to.be.ok() - expect(time).to.be.a("number") - end) - test:Fire() - end) - end) -end \ No newline at end of file diff --git a/test/server.spec.luau b/test/server.spec.luau new file mode 100644 index 0000000..cb2b45a --- /dev/null +++ b/test/server.spec.luau @@ -0,0 +1,34 @@ +--!nocheck + +return function() + local ReplicatedStorage = game:GetService("ReplicatedStorage") + local WarpModule = ReplicatedStorage:WaitForChild("Warp") + local Warp = require(WarpModule) + + describe("Warp.Server()", function() + local Server = Warp.Server() + + it("returns a module with expected functions", function() + expect(type(Server)).to.equal("table") + expect(type(Server.Connect)).to.equal("function") + expect(type(Server.Once)).to.equal("function") + expect(type(Server.Wait)).to.equal("function") + expect(type(Server.DisconnectAll)).to.equal("function") + expect(type(Server.Destroy)).to.equal("function") + expect(type(Server.Fire)).to.equal("function") + expect(type(Server.Fires)).to.equal("function") + expect(type(Server.Invoke)).to.equal("function") + expect(type(Server.useSchema)).to.equal("function") + expect(type(Server.Schema)).to.equal("table") + end) + + it("Connect returns a connection that can disconnect", function() + local conn = Server.Connect("_test_connect", function() end) + expect(conn).to.be.ok() + expect(conn.Connected).to.equal(true) + + conn:Disconnect() + expect(conn.Connected).to.equal(false) + end) + end) +end \ No newline at end of file