@quenty/studio-bridge 0.21.1 → 0.22.0

package/templates/studio-bridge-plugin-test/test/protocol.test.lua

@@ -1,506 +0,0 @@
---[[
-	Tests for Protocol.encode / Protocol.decode.
-
-	Covers round-trip for every message type, error cases, and optional field handling.
-]]
-
-local Protocol = require("../../studio-bridge-plugin/src/Shared/Protocol")
-
--- ---------------------------------------------------------------------------
--- Test helpers
--- ---------------------------------------------------------------------------
-
-local function assertEqual(actual: any, expected: any, label: string?)
-	if actual ~= expected then
-		error(
-			string.format(
-				"%sexpected %s, got %s",
-				if label then label .. ": " else "",
-				tostring(expected),
-				tostring(actual)
-			)
-		)
-	end
-end
-
-local function assertNil(value: any, label: string?)
-	if value ~= nil then
-		error(string.format("%sexpected nil, got %s", if label then label .. ": " else "", tostring(value)))
-	end
-end
-
-local function assertNotNil(value: any, label: string?)
-	if value == nil then
-		error(string.format("%sexpected non-nil value", if label then label .. ": " else ""))
-	end
-end
-
-local function assertContains(str: string, substring: string, label: string?)
-	if not string.find(str, substring, 1, true) then
-		error(
-			string.format(
-				"%sexpected string to contain '%s', got '%s'",
-				if label then label .. ": " else "",
-				substring,
-				str
-			)
-		)
-	end
-end
-
--- ---------------------------------------------------------------------------
--- Round-trip helper
--- ---------------------------------------------------------------------------
-
-local function roundTrip(message: { [string]: any }): { [string]: any }
-	local encoded = Protocol.encode(message :: any)
-	local decoded, err = Protocol.decode(encoded)
-	if decoded == nil then
-		error("round-trip decode failed: " .. tostring(err))
-	end
-	return decoded :: any
-end
-
--- ---------------------------------------------------------------------------
--- Tests
--- ---------------------------------------------------------------------------
-
-local tests = {}
-
-
--- 3. Round-trip: scriptComplete
-table.insert(tests, {
-	name = "round-trip scriptComplete",
-	fn = function()
-		local msg = {
-			type = "scriptComplete",
-			sessionId = "sess-003",
-			payload = { success = true },
-		}
-		local result = roundTrip(msg)
-		assertEqual(result.type, "scriptComplete")
-		assertEqual(result.payload.success, true)
-	end,
-})
-
--- 4. Round-trip: register
-table.insert(tests, {
-	name = "round-trip register",
-	fn = function()
-		local msg = {
-			type = "register",
-			sessionId = "sess-004",
-			payload = {
-				pluginVersion = "1.0.0",
-				instanceId = "inst-xyz",
-				context = "edit",
-				placeName = "TestPlace",
-				placeId = 123,
-				gameId = 456,
-				state = "Edit",
-				capabilities = { "execute", "queryState" },
-			},
-		}
-		local result = roundTrip(msg)
-		assertEqual(result.type, "register")
-		assertEqual(result.payload.pluginVersion, "1.0.0")
-		assertEqual(result.payload.instanceId, "inst-xyz")
-	end,
-})
-
--- 6. Round-trip: execute
-table.insert(tests, {
-	name = "round-trip execute",
-	fn = function()
-		local msg = {
-			type = "execute",
-			sessionId = "sess-006",
-			requestId = "req-001",
-			payload = { script = "print('hi')" },
-		}
-		local result = roundTrip(msg)
-		assertEqual(result.type, "execute")
-		assertEqual(result.requestId, "req-001")
-		assertEqual(result.payload.script, "print('hi')")
-	end,
-})
-
--- 7. Round-trip: shutdown
-table.insert(tests, {
-	name = "round-trip shutdown",
-	fn = function()
-		local msg = {
-			type = "shutdown",
-			sessionId = "sess-007",
-			payload = {},
-		}
-		local result = roundTrip(msg)
-		assertEqual(result.type, "shutdown")
-		assertEqual(result.sessionId, "sess-007")
-	end,
-})
-
--- 8. Round-trip: queryState / stateResult
-table.insert(tests, {
-	name = "round-trip queryState and stateResult",
-	fn = function()
-		local query = {
-			type = "queryState",
-			sessionId = "sess-008",
-			requestId = "req-qs",
-			payload = {},
-		}
-		local qResult = roundTrip(query)
-		assertEqual(qResult.type, "queryState")
-		assertEqual(qResult.requestId, "req-qs")
-
-		local response = {
-			type = "stateResult",
-			sessionId = "sess-008",
-			requestId = "req-qs",
-			payload = {
-				state = "Edit",
-				placeId = 123,
-				placeName = "TestPlace",
-				gameId = 456,
-			},
-		}
-		local sResult = roundTrip(response)
-		assertEqual(sResult.type, "stateResult")
-		assertEqual(sResult.payload.state, "Edit")
-		assertEqual(sResult.payload.placeId, 123)
-	end,
-})
-
--- 9. Round-trip: captureScreenshot / screenshotResult
-table.insert(tests, {
-	name = "round-trip captureScreenshot and screenshotResult",
-	fn = function()
-		local capture = {
-			type = "captureScreenshot",
-			sessionId = "sess-009",
-			requestId = "req-cs",
-			payload = { format = "png" },
-		}
-		local cResult = roundTrip(capture)
-		assertEqual(cResult.type, "captureScreenshot")
-
-		local response = {
-			type = "screenshotResult",
-			sessionId = "sess-009",
-			requestId = "req-cs",
-			payload = {
-				data = "iVBORw0KGgo=",
-				format = "png",
-				width = 1920,
-				height = 1080,
-			},
-		}
-		local sResult = roundTrip(response)
-		assertEqual(sResult.type, "screenshotResult")
-		assertEqual(sResult.payload.width, 1920)
-	end,
-})
-
--- 10. Round-trip: queryDataModel / dataModelResult
-table.insert(tests, {
-	name = "round-trip queryDataModel and dataModelResult",
-	fn = function()
-		local query = {
-			type = "queryDataModel",
-			sessionId = "sess-010",
-			requestId = "req-dm",
-			payload = { path = "game.Workspace", depth = 1 },
-		}
-		local qResult = roundTrip(query)
-		assertEqual(qResult.type, "queryDataModel")
-		assertEqual(qResult.payload.path, "game.Workspace")
-
-		local response = {
-			type = "dataModelResult",
-			sessionId = "sess-010",
-			requestId = "req-dm",
-			payload = {
-				instance = {
-					name = "Workspace",
-					className = "Workspace",
-					path = "game.Workspace",
-					properties = {},
-					attributes = {},
-					childCount = 3,
-				},
-			},
-		}
-		local dResult = roundTrip(response)
-		assertEqual(dResult.type, "dataModelResult")
-		assertEqual(dResult.payload.instance.name, "Workspace")
-		assertEqual(dResult.payload.instance.childCount, 3)
-	end,
-})
-
--- 11. Round-trip: queryLogs / logsResult
-table.insert(tests, {
-	name = "round-trip queryLogs and logsResult",
-	fn = function()
-		local query = {
-			type = "queryLogs",
-			sessionId = "sess-011",
-			requestId = "req-ql",
-			payload = { count = 50, direction = "tail" },
-		}
-		local qResult = roundTrip(query)
-		assertEqual(qResult.type, "queryLogs")
-		assertEqual(qResult.payload.count, 50)
-
-		local response = {
-			type = "logsResult",
-			sessionId = "sess-011",
-			requestId = "req-ql",
-			payload = {
-				entries = {
-					{ level = "Print", body = "hello", timestamp = 1000 },
-				},
-				total = 1,
-				bufferCapacity = 1000,
-			},
-		}
-		local lResult = roundTrip(response)
-		assertEqual(lResult.type, "logsResult")
-		assertEqual(lResult.payload.total, 1)
-		assertEqual(lResult.payload.entries[1].body, "hello")
-	end,
-})
-
--- 12. Round-trip: subscribe / subscribeResult / unsubscribe / unsubscribeResult
-table.insert(tests, {
-	name = "round-trip subscribe and unsubscribe flows",
-	fn = function()
-		local sub = {
-			type = "subscribe",
-			sessionId = "sess-012",
-			requestId = "req-sub",
-			payload = { events = { "stateChange", "logPush" } },
-		}
-		local subResult = roundTrip(sub)
-		assertEqual(subResult.type, "subscribe")
-		assertEqual(#subResult.payload.events, 2)
-
-		local subConfirm = {
-			type = "subscribeResult",
-			sessionId = "sess-012",
-			requestId = "req-sub",
-			payload = { events = { "stateChange", "logPush" } },
-		}
-		local scResult = roundTrip(subConfirm)
-		assertEqual(scResult.type, "subscribeResult")
-
-		local unsub = {
-			type = "unsubscribe",
-			sessionId = "sess-012",
-			requestId = "req-unsub",
-			payload = { events = { "stateChange" } },
-		}
-		local unsubResult = roundTrip(unsub)
-		assertEqual(unsubResult.type, "unsubscribe")
-
-		local unsubConfirm = {
-			type = "unsubscribeResult",
-			sessionId = "sess-012",
-			requestId = "req-unsub",
-			payload = { events = { "stateChange" } },
-		}
-		local ucResult = roundTrip(unsubConfirm)
-		assertEqual(ucResult.type, "unsubscribeResult")
-	end,
-})
-
--- 13. Round-trip: stateChange (push message, no requestId)
-table.insert(tests, {
-	name = "round-trip stateChange push",
-	fn = function()
-		local msg = {
-			type = "stateChange",
-			sessionId = "sess-013",
-			payload = {
-				previousState = "Edit",
-				newState = "Play",
-				timestamp = 47230,
-			},
-		}
-		local result = roundTrip(msg)
-		assertEqual(result.type, "stateChange")
-		assertEqual(result.payload.previousState, "Edit")
-		assertEqual(result.payload.newState, "Play")
-		assertNil(result.requestId)
-	end,
-})
-
--- 14. Round-trip: heartbeat
-table.insert(tests, {
-	name = "round-trip heartbeat",
-	fn = function()
-		local msg = {
-			type = "heartbeat",
-			sessionId = "sess-014",
-			payload = {
-				uptimeMs = 45000,
-				state = "Edit",
-				pendingRequests = 0,
-			},
-		}
-		local result = roundTrip(msg)
-		assertEqual(result.type, "heartbeat")
-		assertEqual(result.payload.uptimeMs, 45000)
-		assertEqual(result.payload.pendingRequests, 0)
-		assertNil(result.requestId)
-	end,
-})
-
--- 15. Round-trip: error (bidirectional)
-table.insert(tests, {
-	name = "round-trip error message",
-	fn = function()
-		local msg = {
-			type = "error",
-			sessionId = "sess-015",
-			requestId = "req-err",
-			payload = {
-				code = "INSTANCE_NOT_FOUND",
-				message = "No instance found at path: game.Workspace.NonExistent",
-				details = { resolvedTo = "game.Workspace", failedSegment = "NonExistent" },
-			},
-		}
-		local result = roundTrip(msg)
-		assertEqual(result.type, "error")
-		assertEqual(result.requestId, "req-err")
-		assertEqual(result.payload.code, "INSTANCE_NOT_FOUND")
-		assertEqual(result.payload.details.failedSegment, "NonExistent")
-	end,
-})
-
--- 16. Error case: invalid JSON
-table.insert(tests, {
-	name = "decode rejects invalid JSON",
-	fn = function()
-		local result, err = Protocol.decode("not valid json {{{")
-		assertNil(result, "result")
-		assertNotNil(err, "error")
-		assertContains(err :: string, "invalid JSON")
-	end,
-})
-
--- 17. Error case: unknown message type
-table.insert(tests, {
-	name = "decode rejects unknown message type",
-	fn = function()
-		local json = '{"type":"unknownType","sessionId":"x","payload":{}}'
-		local result, err = Protocol.decode(json)
-		assertNil(result, "result")
-		assertNotNil(err, "error")
-		assertContains(err :: string, "unknown message type")
-		assertContains(err :: string, "unknownType")
-	end,
-})
-
--- 18. Error case: missing sessionId
-table.insert(tests, {
-	name = "decode rejects missing sessionId",
-	fn = function()
-		local json = '{"type":"register","payload":{}}'
-		local result, err = Protocol.decode(json)
-		assertNil(result, "result")
-		assertNotNil(err, "error")
-		assertContains(err :: string, "sessionId")
-	end,
-})
-
--- 19. Error case: missing payload
-table.insert(tests, {
-	name = "decode rejects missing payload",
-	fn = function()
-		local json = '{"type":"register","sessionId":"x"}'
-		local result, err = Protocol.decode(json)
-		assertNil(result, "result")
-		assertNotNil(err, "error")
-		assertContains(err :: string, "payload")
-	end,
-})
-
--- 20. Error case: missing type
-table.insert(tests, {
-	name = "decode rejects missing type",
-	fn = function()
-		local json = '{"sessionId":"x","payload":{}}'
-		local result, err = Protocol.decode(json)
-		assertNil(result, "result")
-		assertNotNil(err, "error")
-		assertContains(err :: string, "type")
-	end,
-})
-
--- 21. requestId preserved when present, absent when nil
-table.insert(tests, {
-	name = "requestId preserved when present, absent when nil",
-	fn = function()
-		-- With requestId
-		local withId = {
-			type = "execute",
-			sessionId = "sess-rid",
-			requestId = "req-123",
-			payload = { script = "x" },
-		}
-		local result1 = roundTrip(withId)
-		assertEqual(result1.requestId, "req-123")
-
-		-- Without requestId
-		local withoutId = {
-			type = "execute",
-			sessionId = "sess-rid",
-			payload = { script = "x" },
-		}
-		local result2 = roundTrip(withoutId)
-		assertNil(result2.requestId)
-	end,
-})
-
--- 23. Encode omits nil optional fields from JSON output
-table.insert(tests, {
-	name = "encode omits nil requestId",
-	fn = function()
-		local msg = {
-			type = "register",
-			sessionId = "sess-omit",
-			payload = { sessionId = "sess-omit" },
-		}
-		local json = Protocol.encode(msg :: any)
-		-- The JSON string should not contain requestId
-		if string.find(json, "requestId", 1, true) then
-			error("JSON should not contain requestId when nil")
-		end
-	end,
-})
-
--- 24. Decode handles non-object JSON (e.g., array, string, number)
-table.insert(tests, {
-	name = "decode rejects non-object JSON values",
-	fn = function()
-		-- JSON array
-		local r1, e1 = Protocol.decode("[1,2,3]")
-		-- serde.decode("[1,2,3]") returns a table, but it won't have type/sessionId/payload
-		-- so it should fail on the "type" check
-		assertNil(r1, "array result")
-		assertNotNil(e1, "array error")
-
-		-- JSON string
-		local r2, e2 = Protocol.decode('"hello"')
-		assertNil(r2, "string result")
-		assertNotNil(e2, "string error")
-
-		-- JSON number
-		local r3, e3 = Protocol.decode("42")
-		assertNil(r3, "number result")
-		assertNotNil(e3, "number error")
-	end,
-})
-
-return tests

package/templates/studio-bridge-plugin-test/test/roblox-mocks.lua

@@ -1,108 +0,0 @@
---[[
-	Minimal Roblox service stubs for running plugin tests under Lune.
-
-	Provides mock implementations of HttpService, RunService, LogService,
-	and a simple Signal class. These are not full Roblox API replicas --
-	only the subset needed by the studio-bridge plugin modules.
-]]
-
-local serde = require("@lune/serde")
-
--- ---------------------------------------------------------------------------
--- Signal mock
--- ---------------------------------------------------------------------------
-
-local Signal = {}
-Signal.__index = Signal
-
-function Signal.new()
-	return setmetatable({
-		_callbacks = {},
-	}, Signal)
-end
-
-function Signal:Connect(callback: (...any) -> ())
-	local connection = {
-		_signal = self,
-		_callback = callback,
-		Connected = true,
-	}
-
-	function connection:Disconnect()
-		self.Connected = false
-		for i, cb in self._signal._callbacks do
-			if cb == self._callback then
-				table.remove(self._signal._callbacks, i)
-				break
-			end
-		end
-	end
-
-	table.insert(self._callbacks, callback)
-	return connection
-end
-
-function Signal:Fire(...)
-	-- Copy the list so disconnects during iteration are safe
-	local snapshot = table.clone(self._callbacks)
-	for _, callback in snapshot do
-		callback(...)
-	end
-end
-
--- ---------------------------------------------------------------------------
--- HttpService mock
--- ---------------------------------------------------------------------------
-
-local HttpService = {}
-
-function HttpService:JSONEncode(value: any): string
-	return serde.encode("json", value)
-end
-
-function HttpService:JSONDecode(json: string): any
-	return serde.decode("json", json)
-end
-
--- ---------------------------------------------------------------------------
--- RunService mock
--- ---------------------------------------------------------------------------
-
-local RunService = {
-	Heartbeat = Signal.new(),
-}
-
-function RunService:IsStudio(): boolean
-	return true
-end
-
-function RunService:IsRunning(): boolean
-	return false
-end
-
-function RunService:IsClient(): boolean
-	return false
-end
-
-function RunService:IsServer(): boolean
-	return false
-end
-
--- ---------------------------------------------------------------------------
--- LogService mock
--- ---------------------------------------------------------------------------
-
-local LogService = {
-	MessageOut = Signal.new(),
-}
-
--- ---------------------------------------------------------------------------
--- Module export
--- ---------------------------------------------------------------------------
-
-return {
-	Signal = Signal,
-	HttpService = HttpService,
-	RunService = RunService,
-	LogService = LogService,
-}