Module:Arguments/testcases

Documentation for this module may be created at Module:Arguments/testcases/doc

--[[
Module:Arguments/tests
Unit tests for Module:Arguments
--]]

local ScribuntoUnit = require('Module:ScribuntoUnit')
local Arguments = require('Module:Arguments')
local suite = ScribuntoUnit:new()

-- ----------------------------------------------------------------------------
-- Helper function to mock the Scribunto frame and parent frame
-- ----------------------------------------------------------------------------
local function createMockFrame(frameArgs, parentArgs)
    local frame = {
        args = frameArgs or {}
    }
    if parentArgs then
        frame.getParent = function()
            return { args = parentArgs }
        end
    else
        frame.getParent = function()
            return nil
        end
    end
    return frame
end

-- ----------------------------------------------------------------------------
-- Tests
-- ----------------------------------------------------------------------------

function suite:testDefaultBehavior()
    local frame = createMockFrame(
        { [1] = "  val1  ", [2] = "", [3] = "val3" }, -- frame args
        { ["a"] = "  A  ", ["b"] = "" }              -- parent args
    )
    local args = Arguments.getArgs(frame)

    self:assertEquals("val1", args[1], "Should trim whitespace from frame args")
    self:assertEquals(nil, args[2], "Should remove blank frame args")
    self:assertEquals("val3", args[3], "Should retain normal frame args")
    self:assertEquals("A", args.a, "Should fetch and trim parent args")
    self:assertEquals(nil, args.b, "Should remove blank parent args")
end

function suite:testDisableTrim()
    local frame = createMockFrame({ [1] = "  val1  " })
    local args = Arguments.getArgs(frame, { trim = false })
    
    self:assertEquals("  val1  ", args[1], "Should preserve whitespace when trim=false")
end

function suite:testDisableRemoveBlanks()
    local frame = createMockFrame({ [1] = "" })
    local args = Arguments.getArgs(frame, { removeBlanks = false })
    
    self:assertEquals("", args[1], "Should preserve empty strings when removeBlanks=false")
end

function suite:testFrameOnly()
    local frame = createMockFrame({ [1] = "frame_val" }, { [1] = "parent_val" })
    local args = Arguments.getArgs(frame, { frameOnly = true })
    
    self:assertEquals("frame_val", args[1], "Should only fetch from frame")
    self:assertEquals(nil, args[2], "Should ignore parent frame")
end

function suite:testParentOnly()
    local frame = createMockFrame({ [1] = "frame_val" }, { [1] = "parent_val" })
    local args = Arguments.getArgs(frame, { parentOnly = true })
    
    self:assertEquals("parent_val", args[1], "Should only fetch from parent frame")
end

function suite:testPrecedence()
    local frame = createMockFrame({ ["conflict"] = "frame_val" }, { ["conflict"] = "parent_val" })
    
    -- Default precedence: Frame wins
    local argsDefault = Arguments.getArgs(frame)
    self:assertEquals("frame_val", argsDefault.conflict, "Frame should override parent by default")
    
    -- parentFirst precedence: Parent wins
    local argsParentFirst = Arguments.getArgs(frame, { parentFirst = true })
    self:assertEquals("parent_val", argsParentFirst.conflict, "Parent should override frame when parentFirst=true")
end

function suite:testValueFunc()
    local frame = createMockFrame({ ["num"] = "42", ["str"] = "hello" })
    
    -- A custom function that converts a specific parameter into a number
    local function myValueFunc(key, val)
        if key == "num" then
            return tonumber(val)
        end
        return val
    end
    
    local args = Arguments.getArgs(frame, { valueFunc = myValueFunc })
    
    self:assertEquals(42, args.num, "valueFunc should transform '42' string to a number")
    self:assertEquals("number", type(args.num), "Type should be translated to number")
    self:assertEquals("hello", args.str, "valueFunc should leave other values unchanged")
end

function suite:testPairsIterator()
    local frame = createMockFrame(
        { ["a"] = "1", ["b"] = "" }, 
        { ["c"] = "3", ["a"] = "ignored" }
    )
    local args = Arguments.getArgs(frame)
    
    local iteratedKeys = {}
    for k, v in pairs(args) do
        iteratedKeys[k] = v
    end
    
    self:assertEquals("1", iteratedKeys.a, "Pairs should iterate over frame args and respect precedence")
    self:assertEquals(nil, iteratedKeys.b, "Pairs should skip blank args (if stripped)")
    self:assertEquals("3", iteratedKeys.c, "Pairs should iterate over parent args")
end

return suite