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 }
 110                 }
 111         }
 112         local decoder = json.decode.getDecoder(strict)
 113         assert(decoder("call(1)").name == 'call')
 114 end
 115
 116 function test_not_defined_fail()
 117         local decoder = json.decode.getDecoder({
 118                 calls = {
 119                         allowUndefined = false
 120                 }
 121         })
 122         assert_error(function()
 123                 decoder("call(1)")
 124         end)
 125 end
 126
 127 function test_not_defined_succeed()
 128         local decoder = json.decode.getDecoder({
 129                 calls = {
 130                         allowUndefined = true
 131                 }
 132         })
 133         assert(decoder("call(1)").name == 'call')
 134 end
 135
 136 -- Test for a name that is not a string
 137 function test_name_not_string()
 138         local notString = {
 139                 true, false, 0/0, 1/0, -1/0, 0, 1, {}, function() end, coroutine.create(function() end)
 140         }
 141         for _, v in ipairs(notString) do
 142                 assert_error(function()
 143                         local defs = {
 144                                 [v] = function() end
 145                         }
 146                         local strict = {
 147                                 calls = { defs = defs }
 148                         }
 149                         json.decode.getDecoder(strict)
 150                 end)
 151         end
 152 end
 153
 154 -- Test for a name that is a string or a pattern
 155 function test_name_matches_string_or_pattern()
 156         local matchedValues = {
 157                 ["mystring"] = "mystring",
 158                 [lpeg.C(lpeg.P("m") * (lpeg.P("y") + lpeg.P("Y")) * "string")] = "mystring",
 159                 [lpeg.C(lpeg.P("m") * (lpeg.P("y") + lpeg.P("Y")) * "string")] = "mYstring"
 160         }
 161         for pattern, value in pairs(matchedValues) do
 162                 local matched = false
 163                 local function mustBeCalled(capturedName, ...)
 164                         assert_equal(value, capturedName)
 165                         matched = true
 166                 end
 167                 matched = false
 168                 local strict = {
 169                         calls = { defs = {
 170                                 [pattern] = mustBeCalled
 171                         } }
 172                 }
 173                 json.decode.getDecoder(strict)(value .. "(true)")
 174                 assert_true(matched, "Value <" .. value .. "> did not match the given pattern")
 175         end
 176 end