fixes to run individual

testing/__tests__/module_loader_test.lua

@@ -1,8 +1,16 @@
-local lu = require("testing.luaunit")
-local loveStub = require("testing.loveStub")
+package.path = package.path .. ";./?.lua;./modules/?.lua"
+local originalSearchers = package.searchers or package.loaders
+table.insert(originalSearchers, 2, function(modname)
+  if modname:match("^FlexLove%.modules%.") then
+    local moduleName = modname:gsub("^FlexLove%.modules%.", "")
+    return function()
+      return require("modules." .. moduleName)
+    end
+  end
+end)
 
--- Set up love stub globally
-_G.love = loveStub
+local luaunit = require("testing.luaunit")
+require("testing.loveStub")
 
 -- Load modules
 local function req(name)
@@ -37,24 +45,24 @@ function TestModuleLoader:test_safeRequire_loads_existing_module()
   -- Test loading an existing required module
   local utils = ModuleLoader.safeRequire(modulePath .. "modules.utils", false)
 
-  lu.assertNotNil(utils)
-  lu.assertIsTable(utils)
-  lu.assertIsNil(utils._isStub)
+  luaunit.assertNotNil(utils)
+  luaunit.assertIsTable(utils)
+  luaunit.assertIsNil(utils._isStub)
 end
 
 function TestModuleLoader:test_safeRequire_returns_stub_for_missing_optional_module()
   -- Test loading a non-existent optional module
   local fakeModule = ModuleLoader.safeRequire(modulePath .. "modules.NonExistentModule", true)
 
-  lu.assertNotNil(fakeModule)
-  lu.assertIsTable(fakeModule)
-  lu.assertTrue(fakeModule._isStub)
-  lu.assertEquals(fakeModule._moduleName, modulePath .. "modules.NonExistentModule")
+  luaunit.assertNotNil(fakeModule)
+  luaunit.assertIsTable(fakeModule)
+  luaunit.assertTrue(fakeModule._isStub)
+  luaunit.assertEquals(fakeModule._moduleName, modulePath .. "modules.NonExistentModule")
 end
 
 function TestModuleLoader:test_safeRequire_throws_error_for_missing_required_module()
   -- Test loading a non-existent required module should throw error
-  lu.assertErrorMsgContains("Required module", function()
+  luaunit.assertErrorMsgContains("Required module", function()
     ModuleLoader.safeRequire(modulePath .. "modules.NonExistentModule", false)
   end)
 end
@@ -62,23 +70,23 @@ end
 function TestModuleLoader:test_stub_has_safe_init_method()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
-  lu.assertIsFunction(stub.init)
+  luaunit.assertIsFunction(stub.init)
   local result = stub.init()
-  lu.assertEquals(result, stub)
+  luaunit.assertEquals(result, stub)
 end
 
 function TestModuleLoader:test_stub_has_safe_new_method()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
-  lu.assertIsFunction(stub.new)
+  luaunit.assertIsFunction(stub.new)
   local result = stub.new()
-  lu.assertEquals(result, stub)
+  luaunit.assertEquals(result, stub)
 end
 
 function TestModuleLoader:test_stub_has_safe_draw_method()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
-  lu.assertIsFunction(stub.draw)
+  luaunit.assertIsFunction(stub.draw)
   -- Should not throw error
   stub.draw()
 end
@@ -86,7 +94,7 @@ end
 function TestModuleLoader:test_stub_has_safe_update_method()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
-  lu.assertIsFunction(stub.update)
+  luaunit.assertIsFunction(stub.update)
   -- Should not throw error
   stub.update()
 end
@@ -94,7 +102,7 @@ end
 function TestModuleLoader:test_stub_has_safe_clear_method()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
-  lu.assertIsFunction(stub.clear)
+  luaunit.assertIsFunction(stub.clear)
   -- Should not throw error
   stub.clear()
 end
@@ -102,17 +110,17 @@ end
 function TestModuleLoader:test_stub_has_safe_clearCache_method()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
-  lu.assertIsFunction(stub.clearCache)
+  luaunit.assertIsFunction(stub.clearCache)
   local result = stub.clearCache()
-  lu.assertIsTable(result)
+  luaunit.assertIsTable(result)
 end
 
 function TestModuleLoader:test_stub_returns_function_for_unknown_properties()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
   -- Unknown properties should return no-op functions for safe method calls
-  lu.assertIsFunction(stub.unknownProperty)
-  lu.assertIsFunction(stub.anotherUnknownProperty)
+  luaunit.assertIsFunction(stub.unknownProperty)
+  luaunit.assertIsFunction(stub.anotherUnknownProperty)
 
   -- Calling unknown methods should not error
   stub:unknownMethod()
@@ -123,23 +131,23 @@ function TestModuleLoader:test_stub_callable_returns_itself()
   local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
   local result = stub()
-  lu.assertEquals(result, stub)
+  luaunit.assertEquals(result, stub)
 end
 
 function TestModuleLoader:test_isModuleLoaded_returns_true_for_loaded_module()
   ModuleLoader.safeRequire(modulePath .. "modules.utils", false)
 
-  lu.assertTrue(ModuleLoader.isModuleLoaded(modulePath .. "modules.utils"))
+  luaunit.assertTrue(ModuleLoader.isModuleLoaded(modulePath .. "modules.utils"))
 end
 
 function TestModuleLoader:test_isModuleLoaded_returns_false_for_stub_module()
   ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
-  lu.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.FakeModule"))
+  luaunit.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.FakeModule"))
 end
 
 function TestModuleLoader:test_isModuleLoaded_returns_false_for_unloaded_module()
-  lu.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.NeverLoaded"))
+  luaunit.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.NeverLoaded"))
 end
 
 function TestModuleLoader:test_getLoadedModules_returns_only_real_modules()
@@ -149,7 +157,7 @@ function TestModuleLoader:test_getLoadedModules_returns_only_real_modules()
 
   local loaded = ModuleLoader.getLoadedModules()
 
-  lu.assertIsTable(loaded)
+  luaunit.assertIsTable(loaded)
   -- Should only contain utils (real module)
   local hasUtils = false
   for _, path in ipairs(loaded) do
@@ -157,7 +165,7 @@ function TestModuleLoader:test_getLoadedModules_returns_only_real_modules()
       hasUtils = true
     end
   end
-  lu.assertTrue(hasUtils)
+  luaunit.assertTrue(hasUtils)
 end
 
 function TestModuleLoader:test_getStubModules_returns_only_stubs()
@@ -167,9 +175,9 @@ function TestModuleLoader:test_getStubModules_returns_only_stubs()
 
   local stubs = ModuleLoader.getStubModules()
 
-  lu.assertIsTable(stubs)
+  luaunit.assertIsTable(stubs)
   -- Should contain 2 stubs
-  lu.assertEquals(#stubs, 2)
+  luaunit.assertEquals(#stubs, 2)
 end
 
 function TestModuleLoader:test_safeRequire_caches_modules()
@@ -178,7 +186,7 @@ function TestModuleLoader:test_safeRequire_caches_modules()
   local module2 = ModuleLoader.safeRequire(modulePath .. "modules.utils", false)
 
   -- Should return same instance
-  lu.assertEquals(module1, module2)
+  luaunit.assertEquals(module1, module2)
 end
 
 function TestModuleLoader:test_safeRequire_caches_stubs()
@@ -187,10 +195,10 @@ function TestModuleLoader:test_safeRequire_caches_stubs()
   local stub2 = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
 
   -- Should return same instance
-  lu.assertEquals(stub1, stub2)
+  luaunit.assertEquals(stub1, stub2)
 end
 
 -- Run tests if executed directly
 if not _G.RUNNING_ALL_TESTS then
-  os.exit(lu.LuaUnit.run())
+  os.exit(luaunit.LuaUnit.run())
 end