@isentinel/jest-roblox 0.2.7 → 0.3.1

package/plugin/out/shared/runner.luau

@@ -1,301 +0,0 @@
---!strict
-local HttpService = game:GetService("HttpService")
-local LogService = game:GetService("LogService")
-
-local InstanceResolver = require(script.Parent:FindFirstChild('instance-resolver'))
-local SetupTiming = require(script.Parent:FindFirstChild('setup-timing'))
-local SnapshotPatch = require(script.Parent:FindFirstChild('snapshot-patch'))
-
-type Config = {
-	jestPath: string?,
-	projects: { string }?,
-	setupFiles: { string }?,
-	setupFilesAfterEnv: { string }?,
-	_coverage: boolean?,
-	_timing: boolean?,
-}
-
-local function fail(err: string)
-	return {
-		success = false,
-		err = err,
-	}
-end
-
-type CapturedMessage = { message: string, messageType: number, timestamp: number }
-
-local function interceptWriteable(writeable: any, buffer: { CapturedMessage }, messageType: number)
-	local original = writeable._writeFn
-	if typeof(original) ~= "function" then
-		return function() end
-	end
-
-	writeable._writeFn = function(data: string)
-		table.insert(buffer, {
-			message = data,
-			messageType = messageType,
-			timestamp = os.clock(),
-		})
-		original(data)
-	end
-
-	return function()
-		writeable._writeFn = original
-	end
-end
-
-local module = {}
-
-function module.run(callingScript: LuaSourceContainer, config: Config): (string, string)
-	local t0 = os.clock()
-	local timingEnabled = config._timing
-	local coverageEnabled = config._coverage
-
-	local t_findJest0 = os.clock()
-	local findSuccess, findValue = pcall(InstanceResolver.getJest, config)
-	local t_findJest = os.clock()
-
-	if not findSuccess then
-		local logSuccess, logHistory = pcall(function()
-			return HttpService:JSONEncode(LogService:GetLogHistory())
-		end)
-
-		return HttpService:JSONEncode(fail(findValue :: any)), if logSuccess then logHistory else "[]"
-	end
-
-	LogService:ClearOutput()
-
-	local snapshotWrites: { [string]: string } = {}
-
-	local t_patchSnapshot0 = os.clock()
-	local patchState = SnapshotPatch.patch(findValue, snapshotWrites)
-	local t_patchSnapshot = os.clock()
-
-	local t_requireJest0 = os.clock()
-	local Jest = (require :: any)(findValue)
-	local t_requireJest = os.clock()
-
-	-- Intercept Jest's stdout/stderr to capture output synchronously.
-	-- Jest writes via process.stdout/stderr (Writeable objects whose _writeFn
-	-- defaults to print). Wrapping _writeFn captures messages like
-	-- "No tests found" that are printed just before exit(1) throws.
-	local capturedMessages: { CapturedMessage } = {}
-	local restoreStdout: (() -> ())?
-	local restoreStderr: (() -> ())?
-
-	local interceptOk = pcall(function()
-		local nodeModules = findValue.Parent.Parent.Parent :: any
-		local RobloxShared = (require :: any)(nodeModules["@rbxts-js"].RobloxShared)
-		local process = RobloxShared.nodeUtils.process
-
-		restoreStdout = interceptWriteable(process.stdout, capturedMessages, 0)
-		restoreStderr = interceptWriteable(process.stderr, capturedMessages, 1)
-	end)
-
-	if not interceptOk then
-		restoreStdout = nil
-		restoreStderr = nil
-	end
-
-	local function runTests()
-		local t_resolveProjects0 = os.clock()
-		local projects = {}
-
-		assert(
-			config.projects and #config.projects > 0,
-			"No projects configured. Set 'projects' in jest.config.ts or pass --projects."
-		)
-
-		for _, projectPath in config.projects do
-			table.insert(projects, InstanceResolver.findInstance(projectPath))
-		end
-
-		config.projects = {}
-		local t_resolveProjects = os.clock()
-
-		local t_resolveSetupFiles0 = os.clock()
-		if config.setupFiles and #config.setupFiles > 0 then
-			local resolved = {}
-
-			for _, setupPath in config.setupFiles do
-				table.insert(resolved, InstanceResolver.findInstance(setupPath))
-			end
-
-			config.setupFiles = resolved :: any
-		end
-		if config.setupFilesAfterEnv and #config.setupFilesAfterEnv > 0 then
-			local resolved = {}
-
-			for _, setupPath in config.setupFilesAfterEnv do
-				table.insert(resolved, InstanceResolver.findInstance(setupPath))
-			end
-
-			config.setupFilesAfterEnv = resolved :: any
-		end
-		local t_resolveSetupFiles = os.clock()
-
-		local setupTimingState = SetupTiming.patch(
-			findValue,
-			config.setupFiles :: any,
-			config.setupFilesAfterEnv :: any
-		)
-
-		-- Strip private keys before Jest.runCLI (safe: single-task execution per VM)
-		config._timing = nil :: any
-		config._coverage = nil :: any
-
-		if coverageEnabled then
-			_G.__jest_roblox_cov = {}
-		end
-
-		local t_jestRunCLI0 = os.clock()
-		local runCLIOk, runCLIValue = pcall(function()
-			return Jest.runCLI(callingScript, config, projects):expect()
-		end)
-		local t_jestRunCLI = os.clock()
-
-		local setupSeconds = SetupTiming.getSeconds(setupTimingState)
-		SetupTiming.unpatch(setupTimingState)
-
-		if not runCLIOk then
-			error(runCLIValue, 0)
-		end
-
-		local jestResult = runCLIValue
-
-		local result: { [string]: any } = {
-			success = true,
-			value = jestResult,
-		}
-
-		if setupSeconds > 0 then
-			result._setup = setupSeconds
-		end
-
-		if timingEnabled then
-			result._timing = {
-				findJest = t_findJest - t_findJest0,
-				patchSnapshot = t_patchSnapshot - t_patchSnapshot0,
-				requireJest = t_requireJest - t_requireJest0,
-				resolveProjects = t_resolveProjects - t_resolveProjects0,
-				resolveSetupFiles = t_resolveSetupFiles - t_resolveSetupFiles0,
-				jestRunCLI = t_jestRunCLI - t_jestRunCLI0,
-				total = os.clock() - t0,
-			}
-		end
-
-		if next(snapshotWrites) then
-			result._snapshotWrites = snapshotWrites
-		end
-
-		if coverageEnabled then
-			result._coverage = _G.__jest_roblox_cov
-		end
-
-		return result
-	end
-
-	local jestDone = false
-	local runSuccess = false
-	local runValue: any = nil
-
-	task.spawn(function()
-		local ok, val = pcall(runTests)
-		jestDone = true
-		runSuccess = ok
-		runValue = val
-	end)
-
-	local infiniteYieldMessage: string? = nil
-	local watchdogConnection = LogService.MessageOut:Connect(function(message: string, messageType: Enum.MessageType)
-		if
-			messageType == Enum.MessageType.MessageWarning
-			and string.find(message, "Infinite yield possible")
-			and not infiniteYieldMessage
-		then
-			infiniteYieldMessage = message
-		end
-	end)
-
-	while not jestDone and not infiniteYieldMessage do
-		task.wait(0.1)
-	end
-
-	watchdogConnection:Disconnect()
-
-	if restoreStdout then
-		restoreStdout()
-	end
-
-	if restoreStderr then
-		restoreStderr()
-	end
-
-	if not jestDone and infiniteYieldMessage then
-		runSuccess = false
-		runValue = "Infinite yield detected, aborting tests: " .. infiniteYieldMessage
-	end
-
-	SnapshotPatch.unpatch(patchState)
-
-	local jestResult
-	if not runSuccess then
-		jestResult = HttpService:JSONEncode(fail(runValue :: any))
-	else
-		jestResult = HttpService:JSONEncode(runValue)
-	end
-
-	local logSuccess, logHistory = pcall(function()
-		return HttpService:JSONEncode(capturedMessages)
-	end)
-
-	return jestResult, if logSuccess then logHistory else "[]"
-end
-
-type ProjectEntry = {
-	jestOutput: string,
-	gameOutput: string,
-	elapsedMs: number,
-}
-
-local function encodeExecutionError(err: any): string
-	return HttpService:JSONEncode({
-		success = true,
-		value = {
-			kind = "ExecutionError",
-			error = tostring(err),
-		},
-	})
-end
-
--- TODO(runner-tests): dogfood harness for Runner.runProjects
-function module.runProjects(
-	callingScript: LuaSourceContainer,
-	configs: { Config }
-): { ProjectEntry }
-	local entries: { ProjectEntry } = {}
-
-	for index, cfg in configs do
-		local start = os.clock()
-		local ok, jestOutput, gameOutput = pcall(module.run, callingScript, cfg)
-		local elapsedMs = math.floor((os.clock() - start) * 1000)
-
-		if ok then
-			entries[index] = {
-				jestOutput = jestOutput :: string,
-				gameOutput = gameOutput :: string,
-				elapsedMs = elapsedMs,
-			}
-		else
-			entries[index] = {
-				jestOutput = encodeExecutionError(jestOutput),
-				gameOutput = "[]",
-				elapsedMs = elapsedMs,
-			}
-		end
-	end
-
-	return entries
-end
-
-return module

package/plugin/out/shared/setup-timing.luau

@@ -1,89 +0,0 @@
---!strict
-local InstanceResolver = require(script.Parent:FindFirstChild('instance-resolver'))
-
-local module = {}
-
-export type PatchState = {
-	Runtime: any,
-	originalRequireModule: any,
-	accumulatedSeconds: { value: number },
-}
-
-function module.patch(
-	jestModule: ModuleScript,
-	setupFiles: { Instance }?,
-	setupFilesAfterEnv: { Instance }?
-): PatchState?
-	local setupSet: { [Instance]: boolean } = {}
-
-	if setupFiles then
-		for _, inst in setupFiles do
-			setupSet[inst] = true
-		end
-	end
-
-	if setupFilesAfterEnv then
-		for _, inst in setupFilesAfterEnv do
-			setupSet[inst] = true
-		end
-	end
-
-	if not next(setupSet) then
-		return nil
-	end
-
-	local jestRuntimeModule = InstanceResolver.findSiblingPackage(jestModule, "JestRuntime", "jest-runtime")
-	if not jestRuntimeModule then
-		warn("Could not find JestRuntime; setup timing unavailable")
-		return nil
-	end
-
-	local Runtime = (require :: any)(jestRuntimeModule)
-	local originalRequireModule = Runtime.requireModule
-	local accumulated = { value = 0 }
-	local insideSetupRequire = false
-
-	Runtime.requireModule = function(self: any, moduleName: any, ...): any
-		if not insideSetupRequire and typeof(moduleName) == "Instance" and setupSet[moduleName] then
-			insideSetupRequire = true
-			local t0 = os.clock()
-			local results = table.pack(pcall(originalRequireModule, self, moduleName, ...))
-			accumulated.value += os.clock() - t0
-			insideSetupRequire = false
-
-			if not results[1] then
-				error(results[2], 0)
-			end
-
-			return table.unpack(results, 2, results.n)
-		end
-
-		return originalRequireModule(self, moduleName, ...)
-	end
-
-	return {
-		Runtime = Runtime,
-		originalRequireModule = originalRequireModule,
-		accumulatedSeconds = accumulated,
-	}
-end
-
-function module.unpatch(state: PatchState?)
-	if not state then
-		return
-	end
-
-	if state.Runtime and state.originalRequireModule then
-		state.Runtime.requireModule = state.originalRequireModule
-	end
-end
-
-function module.getSeconds(state: PatchState?): number
-	if not state then
-		return 0
-	end
-
-	return state.accumulatedSeconds.value
-end
-
-return module

package/plugin/out/shared/snapshot-patch.luau

@@ -1,94 +0,0 @@
---!strict
-local CoreScriptSyncService = require(script.Parent:FindFirstChild('mock'):FindFirstChild('CoreScriptSyncService'))
-local InstanceResolver = require(script.Parent:FindFirstChild('instance-resolver'))
-
-local module = {}
-
-function module.createMockGetDataModelService(snapshotWrites: { [string]: string })
-	local FileSystemService = require(script.Parent:FindFirstChild('mock'):FindFirstChild('FileSystemService'))(snapshotWrites)
-
-	return function(service: string): any
-		if service == "FileSystemService" then
-			return FileSystemService
-		elseif service == "CoreScriptSyncService" then
-			return CoreScriptSyncService
-		end
-
-		local success, result = pcall(function()
-			local service_ = game:GetService(service)
-			local _ = service_.Name
-			return service_
-		end)
-
-		return if success then result else nil
-	end
-end
-
-export type PatchState = {
-	robloxSharedExports: any,
-	originalGetDataModelService: any,
-	Runtime: any,
-	originalRequireInternalModule: any,
-}
-
-function module.patch(jestModule: ModuleScript, snapshotWrites: { [string]: string }): PatchState?
-	local mockGetDataModelService = module.createMockGetDataModelService(snapshotWrites)
-
-	local robloxSharedInstance = InstanceResolver.findRobloxShared(jestModule)
-	if not robloxSharedInstance then
-		warn("Could not find RobloxShared; snapshot support unavailable")
-		return nil
-	end
-
-	local robloxSharedExports = (require :: any)(robloxSharedInstance)
-	local originalGetDataModelService = robloxSharedExports.getDataModelService
-	robloxSharedExports.getDataModelService = mockGetDataModelService
-
-	local getDataModelServiceChild = robloxSharedInstance:FindFirstChild("getDataModelService")
-
-	local jestRuntimeModule = InstanceResolver.findSiblingPackage(jestModule, "JestRuntime", "jest-runtime")
-	if not jestRuntimeModule then
-		warn("Could not find JestRuntime; snapshot interception unavailable")
-		return {
-			robloxSharedExports = robloxSharedExports,
-			originalGetDataModelService = originalGetDataModelService,
-			Runtime = nil,
-			originalRequireInternalModule = nil,
-		}
-	end
-
-	local Runtime = (require :: any)(jestRuntimeModule)
-	local originalRequireInternalModule = Runtime.requireInternalModule
-
-	Runtime.requireInternalModule = function(self: any, from: any, to: any, ...): any
-		local target = if to ~= nil then to else from
-		if getDataModelServiceChild and typeof(target) == "Instance" and target == getDataModelServiceChild then
-			return mockGetDataModelService
-		end
-
-		return originalRequireInternalModule(self, from, to, ...)
-	end
-
-	return {
-		robloxSharedExports = robloxSharedExports,
-		originalGetDataModelService = originalGetDataModelService,
-		Runtime = Runtime,
-		originalRequireInternalModule = originalRequireInternalModule,
-	}
-end
-
-function module.unpatch(state: PatchState?)
-	if not state then
-		return
-	end
-
-	if state.robloxSharedExports and state.originalGetDataModelService then
-		state.robloxSharedExports.getDataModelService = state.originalGetDataModelService
-	end
-
-	if state.Runtime and state.originalRequireInternalModule then
-		state.Runtime.requireInternalModule = state.originalRequireInternalModule
-	end
-end
-
-return module