feature: lute test runs specific tests

Author: Vighnesh-V

lute/cli/commands/test/filter.luau

@@ -0,0 +1,74 @@
+local testtypes = require("@std/test/types")
+
+local function filtertests(
+	env: testtypes.testenvironment,
+	suiteName: string?,
+	caseName: string?
+): testtypes.testenvironment
+	local filtered: testtypes.testenvironment = {
+		anonymous = {},
+		suites = {},
+		suiteindex = {},
+		caseindex = {},
+	}
+
+	-- No filters: return all tests
+	if not suiteName and not caseName then
+		return env
+	end
+
+	-- Filter by case name only
+	if caseName and not suiteName then
+		local caseEntry = env.caseindex[caseName]
+		if caseEntry then
+			-- Add all anonymous tests with this case name
+			filtered.anonymous = caseEntry.anonymous
+
+			-- Add all suites that have tests with this case name
+			for sName, cases in caseEntry.suites do
+				local suite = env.suiteindex[sName]
+				local filteredSuite = {
+					name = suite.name,
+					cases = cases,
+					_beforeeach = suite._beforeeach,
+					_beforeall = suite._beforeall,
+					_aftereach = suite._aftereach,
+					_afterall = suite._afterall,
+				}
+				table.insert(filtered.suites, filteredSuite)
+			end
+		end
+		return filtered
+	end
+
+	-- Filter by suite name only
+	if suiteName and not caseName then
+		local suite = env.suiteindex[suiteName]
+		if suite then
+			table.insert(filtered.suites, suite)
+		end
+		return filtered
+	end
+
+	-- Filter by both suite and case name
+	if suiteName and caseName then
+		local caseEntry = env.caseindex[caseName]
+		if caseEntry and caseEntry.suites[suiteName] then
+			local suite = env.suiteindex[suiteName]
+			local filteredSuite = {
+				name = suite.name,
+				cases = caseEntry.suites[suiteName],
+				_beforeeach = suite._beforeeach,
+				_beforeall = suite._beforeall,
+				_aftereach = suite._aftereach,
+				_afterall = suite._afterall,
+			}
+			table.insert(filtered.suites, filteredSuite)
+		end
+		return filtered
+	end
+
+	return filtered
+end
+
+return table.freeze({ filtertests = filtertests })

lute/cli/commands/test/init.luau

@@ -1,4 +1,5 @@
 local finder = require("@self/finder")
+local filter = require("@self/filter")
 local luau = require("@std/luau")
 local path = require("@std/path")
 local ps = require("@std/process")
@@ -16,14 +17,10 @@ Run tests discovered in .test.luau and .spec.luau files.
 OPTIONS:
   -h, --help              Show this help message
   --list                  List all discovered test cases without running them
-  --filter=PATTERN        Run only tests matching PATTERN
-                          Examples:
-                            --filter=SuiteName           (run all tests in suite)
-                            --filter=SuiteName.testname  (run specific test)
-                            --filter=testname            (run anonymous test)
-  --reporter=REPORTER     Choose test reporter (default: rich)
+  -s, --suite=SUITE       Run only tests in the specified suite
+  -c, --case=CASE         Run only test cases matching the specified name
+  --reporter=REPORTER     Choose test reporter (default: simple)
                           Options:
-                            rich    - Color output with visual diffs
                             simple  - Plain text output
                             <path>  - Custom reporter from file path
 
@@ -33,8 +30,9 @@ PATHS:
 EXAMPLES:
   lute test                                    Run all tests in ./tests
   lute test --list                             List all test cases
-  lute test --filter=MyTestSuite               Run all tests in MyTestSuite
-  lute test --reporter=simple src/             Run tests with simple reporter
+  lute test -s MyTestSuite                     Run all tests in MyTestSuite
+  lute test --suite MyTestSuite --case mytest  Run specific test in suite
+  lute test --case "some case"                 Run all test cases named "some case"
 ]])
 end
 
@@ -102,25 +100,52 @@ local function main(...: string)
 	local args = { ... }
 	local testPaths = {}
 	local isListMode = false
+	local suiteName: string? = nil
+	local caseName: string? = nil
+
+	local i = 1
+	while i <= #args do
+		local arg = args[i]
 
-	for _, arg in args do
 		if arg == "-h" or arg == "--help" then
 			printHelp()
 			return
 		elseif arg == "--list" then
 			isListMode = true
+			i += 1
+		elseif arg == "-s" or arg == "--suite" then
+			i += 1
+			if i <= #args then
+				suiteName = args[i]
+				i += 1
+			else
+				print(`Error: {arg} requires a value`)
+				ps.exit(1)
+			end
+		elseif arg == "-c" or arg == "--case" then
+			i += 1
+			if i <= #args then
+				caseName = args[i]
+				i += 1
+			else
+				print(`Error: {arg} requires a value`)
+				ps.exit(1)
+			end
 		else
 			table.insert(testPaths, arg)
+			i += 1
 		end
 	end
+
 	local searchpath = if #testPaths > 0 then testPaths else { "./tests" }
 	loadtests(finder.findtestfiles(searchpath))
 
 	if isListMode then
 		listtests()
 	else
 		local env = test._registered()
-		runtests(env, runner.run, reporter.simple)
+		local filteredEnv = filter.filtertests(env, suiteName, caseName)
+		runtests(filteredEnv, runner.run, reporter.simple)
 	end
 end
 

lute/std/libs/test/init.luau

@@ -49,31 +49,52 @@ function TestSuite:afterall(hook: () -> ())
 	self._afterall = hook
 end
 
-local env: TestEnvironment = { anonymous = {}, suites = {}, reporter = reporter.simple }
+local env: TestEnvironment = { anonymous = {}, suites = {}, suiteindex = {}, caseindex = {} }
 
 -- Test library export surface
 local test = {}
 
-function test.setreporter(reporter: TestReporter)
-	test.reporter = reporter
-end
-
 -- register an anonymous test case
 function test.case(name: string, case: Test)
 	local testcase = { name = name, case = case }
 	table.insert(env.anonymous, testcase)
+
+	-- Update caseindex
+	if not env.caseindex[name] then
+		env.caseindex[name] = { anonymous = {}, suites = {} }
+	end
+	table.insert(env.caseindex[name].anonymous, testcase)
 end
 
 -- register a test suite
 function test.suite(name: string, registerFn: (TestSuite) -> ())
 	local suite = TestSuite.new(name)
 	registerFn(suite)
 	table.insert(env.suites, suite)
+
+	-- Update suiteindex
+	env.suiteindex[name] = suite
+
+	-- Update caseindex for all cases in this suite
+	for _, testcase in suite.cases do
+		if not env.caseindex[testcase.name] then
+			env.caseindex[testcase.name] = { anonymous = {}, suites = {} }
+		end
+		if not env.caseindex[testcase.name].suites[name] then
+			env.caseindex[testcase.name].suites[name] = {}
+		end
+		table.insert(env.caseindex[testcase.name].suites[name], testcase)
+	end
 end
 
 -- get all registered tests without running them (internal)
 function test._registered()
-	return table.freeze({ anonymous = env.anonymous, suites = env.suites })
+	return table.freeze({
+		anonymous = env.anonymous,
+		suites = env.suites,
+		suiteindex = env.suiteindex,
+		caseindex = env.caseindex,
+	})
 end
 
 -- run all the tests

lute/std/libs/test/types.luau

@@ -41,10 +41,16 @@ export type testrunresult = {
 export type testreporter = (testrunresult) -> ()
 
 -- Testing Environment
+export type caseindexentry = {
+	anonymous: { testcase },
+	suites: { [string]: { testcase } },
+}
+
 export type testenvironment = {
 	anonymous: { testcase },
 	suites: { testsuite },
-	reporter: testreporter,
+	suiteindex: { [string]: testsuite },
+	caseindex: { [string]: caseindexentry },
 }
 
 export type testrunner = (testenvironment) -> testrunresult

tests/cli/test.test.luau

@@ -127,6 +127,8 @@ test.run()
 
 		fs.remove(testFilePath)
 	end)
+<<<<<<< Conflict 1 of 1
++++++++ Contents of side #1
 
 	suite:case("assert.eq_error_message_in_case", function(assert)
 		assertErrorsWithMsg(
@@ -368,6 +370,36 @@ test.run()
 			assert
 		)
 	end)
+
+	suite:case("lute test filters by suite name", function(assert)
+		-- Run lute test with --suite flag
+		local result = process.run({ lutePath, "test", "-s", "SmokeSuite", "tests/cli/discovery" })
+
+		-- Check that it runs only tests in SmokeSuite
+		assert.eq(result.exitcode, 0)
+		assert.neq(result.stdout:find("Total: 2", 1, true), nil)
+		assert.neq(result.stdout:find("Passed: 2", 1, true), nil)
+	end)
+
+	suite:case("lute test filters by case name", function(assert)
+		-- Run lute test with --case flag
+		local result = process.run({ lutePath, "test", "--case", "make_pass", "tests/cli/discovery" })
+
+		-- Check that it runs only tests named make_pass
+		assert.eq(result.exitcode, 0)
+		assert.neq(result.stdout:find("Total: 1", 1, true), nil)
+		assert.neq(result.stdout:find("Passed: 1", 1, true), nil)
+	end)
+
+	suite:case("lute test filters by suite and case name", function(assert)
+		-- Run lute test with both --suite and --case flags
+		local result = process.run({ lutePath, "test", "-s", "SmokeSuite", "-c", "make_fail", "tests/cli/discovery" })
+
+		-- Check that it runs only make_fail in SmokeSuite
+		assert.eq(result.exitcode, 0)
+		assert.neq(result.stdout:find("Total: 1", 1, true), nil)
+		assert.neq(result.stdout:find("Passed: 1", 1, true), nil)
+	end)
 end)
 
 test.run()