tests/lunit-calls.lua

   1 local lpeg = require("lpeg")
   2 local json = require("json")
   3 local lunit = require("lunit")
   4 local math = require("math")
   5 local testutil = require("testutil")
   6
   7 local encode = json.encode
   8 -- DECODE NOT 'local' due to requirement for testutil to access it
   9 decode = json.decode.getDecoder(false)
  10
  11 if not module then
  12     _ENV = lunit.module("lunit-calls", 'seeall')
  13 else
  14     module("lunit-calls", lunit.testcase, package.seeall)
  15 end
  16
  17 function setup()
  18         -- Ensure that the decoder is reset
  19         _G["decode"] = json.decode.getDecoder(false)
  20 end
  21
  22 local values = {
  23         0,
  24         1,
  25         0.2,
  26         "Hello",
  27         true,
  28         {hi=true},
  29         {1,2}
  30 }
  31
  32 function test_identity()
  33         local function testFunction(capturedName, ...)
  34                 assert_equal('call', capturedName)
  35                 return (...)
  36         end
  37         local strict = {
  38                 calls = { defs = {
  39                         call = testFunction
  40                 } }
  41         }
  42         local decode = json.decode.getDecoder(strict)
  43         for i, v in ipairs(values) do
  44                 local str = "call(" .. encode(v) .. ")"
  45                 local decoded = decode(str)
  46                 if type(decoded) == 'table' then
  47                         for k2, v2 in pairs(v) do
  48                                 assert_equal(v2, decoded[k2])
  49                                 decoded[k2] = nil
  50                         end
  51                         assert_nil(next(decoded))
  52                 else
  53                         assert_equal(v, decoded)
  54                 end
  55         end
  56 end
  57
  58 -- Test for a function that throws
  59 function test_function_failure()
  60         local function testFunction(...)
  61                 error("CANNOT CONTINUE")
  62         end
  63         local strict = {
  64                 calls = { defs = {
  65                         call = testFunction
  66                 } }
  67         }
  68         local decode = json.decode.getDecoder(strict)
  69         for i, v in ipairs(values) do
  70                 local str = "call(" .. encode(v) .. ")"
  71                 assert_error(function()
  72                         decode(str)
  73                 end)
  74         end
  75 end
  76
  77 -- Test for a function that is not a function
  78 function test_not_a_function_fail()
  79         local notFunction = {
  80                 0/0, 1/0, -1/0, 0, 1, "Hello", {}, coroutine.create(function() end)
  81         }
  82         for _, v in ipairs(notFunction) do
  83                 assert_error(function()
  84                         local strict = {
  85                                 calls = { defs = {
  86                                         call = v
  87                                 }, allowUndefined = false }
  88                         }
  89                         json.decode.getDecoder(strict)
  90                 end)
  91         end
  92 end
  93
  94 function test_not_permitted_fail()
  95         local strict = {
  96                 calls = {
  97                         defs = { call = false }
  98                 }
  99         }
 100         local decoder = json.decode.getDecoder(strict)
 101         assert_error(function()
 102                 decoder("call(1)")
 103         end)
 104 end
 105
 106 function test_permitted()
 107         local strict = {
 108                 calls = {
 109                         defs = { call = true, other = true }
 110                 }
 111         }
 112         local decoder = json.decode.getDecoder(strict)
 113         assert(decoder("call(1)").name == 'call')
 114         assert(decoder("other(1)").name == 'other')
 115 end
 116
 117 function test_permitted_nested()
 118         local strict = {
 119                 calls = {
 120                         defs = { call = true, other = true }
 121                 }
 122         }
 123         local decoder = json.decode.getDecoder(strict)
 124         assert(decoder("call(call(1))").name == 'call')
 125         assert(decoder("other(call(1))").name == 'other')
 126 end
 127
 128 function test_not_defined_fail()
 129         local decoder = json.decode.getDecoder({
 130                 calls = {
 131                         allowUndefined = false
 132                 }
 133         })
 134         assert_error(function()
 135                 decoder("call(1)")
 136         end)
 137 end
 138
 139 function test_not_defined_succeed()
 140         local decoder = json.decode.getDecoder({
 141                 calls = {
 142                         allowUndefined = true
 143                 }
 144         })
 145         assert(decoder("call(1)").name == 'call')
 146 end
 147
 148 -- Test for a name that is not a string
 149 function test_name_not_string()
 150         local notString = {
 151                 true, false, 0/0, 1/0, -1/0, 0, 1, {}, function() end, coroutine.create(function() end)
 152         }
 153         for _, v in ipairs(notString) do
 154                 assert_error(function()
 155                         local defs = {
 156                                 [v] = function() end
 157                         }
 158                         local strict = {
 159                                 calls = { defs = defs }
 160                         }
 161                         json.decode.getDecoder(strict)
 162                 end)
 163         end
 164 end
 165
 166 -- Test for a name that is a string or a pattern
 167 function test_name_matches_string_or_pattern()
 168         local matchedValues = {
 169                 ["mystring"] = "mystring",
 170                 [lpeg.C(lpeg.P("m") * (lpeg.P("y") + lpeg.P("Y")) * "string")] = "mystring",
 171                 [lpeg.C(lpeg.P("m") * (lpeg.P("y") + lpeg.P("Y")) * "string")] = "mYstring"
 172         }
 173         for pattern, value in pairs(matchedValues) do
 174                 local matched = false
 175                 local function mustBeCalled(capturedName, ...)
 176                         assert_equal(value, capturedName)
 177                         matched = true
 178                 end
 179                 matched = false
 180                 local strict = {
 181                         calls = { defs = {
 182                                 [pattern] = mustBeCalled
 183                         } }
 184                 }
 185                 json.decode.getDecoder(strict)(value .. "(true)")
 186                 assert_true(matched, "Value <" .. value .. "> did not match the given pattern")
 187         end
 188 end