treewide: forward compatibility changes
[project/firewall4.git] / tests / lib / mocklib.uc
index d47ebf300ecd15a657bfdfcb8ac1d81a5e2fd301..896efba9fba59e37640961f074195c5c3eb58cc5 100644 (file)
-{%
-       /* strict mode compliance: ensure that global variabes are defined */
-       if (!exists(global, 'REQUIRE_SEARCH_PATH'))
-               global.MOCK_SEARCH_PATH = null;
+/* strict mode compliance: ensure that global variabes are defined */
+if (!exists(global, 'REQUIRE_SEARCH_PATH'))
+       global.MOCK_SEARCH_PATH = null;
 
-       if (!exists(global, 'MOCK_SEARCH_PATH'))
-               global.MOCK_SEARCH_PATH = null;
+if (!exists(global, 'MOCK_SEARCH_PATH'))
+       global.MOCK_SEARCH_PATH = null;
 
-       if (!exists(global, 'TRACE_CALLS'))
-               global.TRACE_CALLS = null;
+if (!exists(global, 'TRACE_CALLS'))
+       global.TRACE_CALLS = null;
 
-       let _fs = require("fs");
+let _fs = require("fs");
 
-       /* Force reloading fs module on next require */
-       delete global.modules.fs;
+/* Force reloading fs module on next require */
+delete global.modules.fs;
 
-       let _log = (level, fmt, ...args) => {
-               let color, prefix;
+let _log = (level, fmt, ...args) => {
+       let color, prefix;
 
-               switch (level) {
-               case 'info':
-                       color = 34;
-                       prefix = '!';
-                       break;
+       switch (level) {
+       case 'info':
+               color = 34;
+               prefix = '!';
+               break;
 
-               case 'warn':
-                       color = 33;
-                       prefix = 'W';
-                       break;
+       case 'warn':
+               color = 33;
+               prefix = 'W';
+               break;
 
-               case 'error':
-                       color = 31;
-                       prefix = 'E';
-                       break;
+       case 'error':
+               color = 31;
+               prefix = 'E';
+               break;
 
-               default:
-                       color = 0;
-                       prefix = 'I';
-               }
+       default:
+               color = 0;
+               prefix = 'I';
+       }
 
-               let f = sprintf("\u001b[%d;1m[%s] %s\u001b[0m", color, prefix, fmt);
-               warn(replace(sprintf(f, ...args), "\n", "\n    "), "\n");
-       };
+       let f = sprintf("\u001b[%d;1m[%s] %s\u001b[0m", color, prefix, fmt);
+       warn(replace(sprintf(f, ...args), "\n", "\n    "), "\n");
+};
 
-       let read_data_file = (path) => {
-               for (let dir in MOCK_SEARCH_PATH) {
-                       let fd = _fs.open(dir + '/' + path, "r");
+let read_data_file = (path) => {
+       for (let dir in MOCK_SEARCH_PATH) {
+               let fd = _fs.open(dir + '/' + path, "r");
 
-                       if (fd) {
-                               let data = fd.read("all");
-                               fd.close();
+               if (fd) {
+                       let data = fd.read("all");
+                       fd.close();
 
-                               return data;
-                       }
+                       return data;
                }
+       }
 
-               return null;
-       };
-
-       let read_json_file = (path) => {
-               let data = read_data_file(path);
+       return null;
+};
 
-               if (data != null)  {
-                       try {
-                               return json(data);
-                       }
-                       catch (e) {
-                               _log('error', "Unable to parse JSON data in %s: %s", path, e);
+let read_json_file = (path) => {
+       let data = read_data_file(path);
 
-                               return NaN;
-                       }
+       if (data != null)  {
+               try {
+                       return json(data);
                }
+               catch (e) {
+                       _log('error', "Unable to parse JSON data in %s: %s", path, e);
 
-               return null;
-       };
-
-       let format_json = (data) => {
-               let rv;
-
-               let format_value = (value) => {
-                       switch (type(value)) {
-                       case "object":
-                               return sprintf("{ /* %d keys */ }", length(value));
+                       return NaN;
+               }
+       }
 
-                       case "array":
-                               return sprintf("[ /* %d items */ ]", length(value));
+       return null;
+};
 
-                       case "string":
-                               if (length(value) > 64)
-                                       value = substr(value, 0, 64) + "...";
+let format_json = (data) => {
+       let rv;
 
-                               /* fall through */
-                               return sprintf("%J", value);
+       let format_value = (value) => {
+               switch (type(value)) {
+               case "object":
+                       return sprintf("{ /* %d keys */ }", length(value));
 
-                       default:
-                               return sprintf("%J", value);
-                       }
-               };
+               case "array":
+                       return sprintf("[ /* %d items */ ]", length(value));
 
-               switch (type(data)) {
-               case "object":
-                       rv = "{";
+               case "string":
+                       if (length(value) > 64)
+                               value = substr(value, 0, 64) + "...";
 
-                       let k = sort(keys(data));
+                       /* fall through */
+                       return sprintf("%J", value);
 
-                       for (let i, n in k)
-                               rv += sprintf("%s %J: %s", i ? "," : "", n, format_value(data[n]));
+               default:
+                       return sprintf("%J", value);
+               }
+       };
 
-                       rv += " }";
-                       break;
+       switch (type(data)) {
+       case "object":
+               rv = "{";
 
-               case "array":
-                       rv = "[";
+               let k = sort(keys(data));
 
-                       for (let i, v in data)
-                               rv += (i ? "," : "") + " " + format_value(v);
+               for (let i, n in k)
+                       rv += sprintf("%s %J: %s", i ? "," : "", n, format_value(data[n]));
 
-                       rv += " ]";
-                       break;
+               rv += " }";
+               break;
 
-               default:
-                       rv = format_value(data);
-               }
+       case "array":
+               rv = "[";
 
-               return rv;
-       };
+               for (let i, v in data)
+                       rv += (i ? "," : "") + " " + format_value(v);
 
-       let trace_call = (ns, func, args) => {
-               let msg = "[call] " +
-                       (ns ? ns + "." : "") +
-                       func;
+               rv += " ]";
+               break;
 
-               for (let k, v in args) {
-                       msg += ' ' + k + ' <';
+       default:
+               rv = format_value(data);
+       }
 
-                       switch (type(v)) {
-                       case "array":
-                       case "object":
-                               msg += format_json(v);
-                               break;
+       return rv;
+};
 
-                       default:
-                               msg += v;
-                       }
+let trace_call = (ns, func, args) => {
+       let msg = "[call] " +
+               (ns ? ns + "." : "") +
+               func;
 
-                       msg += '>';
-               }
+       for (let k, v in args) {
+               msg += ' ' + k + ' <';
 
-               switch (TRACE_CALLS) {
-               case '1':
-               case 'stdout':
-                       _fs.stdout.write(msg + "\n");
+               switch (type(v)) {
+               case "array":
+               case "object":
+                       msg += format_json(v);
                        break;
 
-               case 'stderr':
-                       _fs.stderr.write(msg + "\n");
-                       break;
+               default:
+                       msg += v;
                }
-       };
-
-       /* Prepend mocklib to REQUIRE_SEARCH_PATH */
-       for (let pattern in REQUIRE_SEARCH_PATH) {
-               /* Only consider ucode includes */
-               if (!match(pattern, /\*\.uc$/))
-                       continue;
-
-               let path = replace(pattern, /\*/, 'mocklib'),
-                   stat = _fs.stat(path);
 
-               if (!stat || stat.type != 'file')
-                       continue;
+               msg += '>';
+       }
 
-               if (type(MOCK_SEARCH_PATH) != 'array' || length(MOCK_SEARCH_PATH) == 0)
-                       MOCK_SEARCH_PATH = [ replace(path, /mocklib\.uc$/, '../mocks') ];
+       switch (TRACE_CALLS) {
+       case '1':
+       case 'stdout':
+               _fs.stdout.write(msg + "\n");
+               break;
 
-               unshift(REQUIRE_SEARCH_PATH, replace(path, /mocklib\.uc$/, 'mocklib/*.uc'));
+       case 'stderr':
+               _fs.stderr.write(msg + "\n");
                break;
        }
+};
+
+/* Prepend mocklib to REQUIRE_SEARCH_PATH */
+for (let pattern in REQUIRE_SEARCH_PATH) {
+       /* Only consider ucode includes */
+       if (!match(pattern, /\*\.uc$/))
+               continue;
+
+       let path = replace(pattern, /\*/, 'mocklib'),
+           stat = _fs.stat(path);
+
+       if (!stat || stat.type != 'file')
+               continue;
 
        if (type(MOCK_SEARCH_PATH) != 'array' || length(MOCK_SEARCH_PATH) == 0)
-               MOCK_SEARCH_PATH = [ './mocks' ];
+               MOCK_SEARCH_PATH = [ replace(path, /mocklib\.uc$/, '../mocks') ];
 
-       let _print = global.print;
+       unshift(REQUIRE_SEARCH_PATH, replace(path, /mocklib\.uc$/, 'mocklib/*.uc'));
+       break;
+}
 
-       /* Register global mocklib namespace */
-       global.mocklib = {
-               require: function(module) {
-                       let path, res, ex;
+if (type(MOCK_SEARCH_PATH) != 'array' || length(MOCK_SEARCH_PATH) == 0)
+       MOCK_SEARCH_PATH = [ './mocks' ];
 
-                       if (type(REQUIRE_SEARCH_PATH) == "array" && index(REQUIRE_SEARCH_PATH[0], 'mocklib/*.uc') != -1)
-                               path = shift(REQUIRE_SEARCH_PATH);
+let _print = global.print;
 
-                       try {
-                               res = require(module);
-                       }
-                       catch (e) {
-                               ex = e;
-                       }
+/* Register global mocklib namespace */
+global.mocklib = {
+       require: function(module) {
+               let path, res, ex;
 
-                       if (path)
-                               unshift(REQUIRE_SEARCH_PATH, path);
+               if (type(REQUIRE_SEARCH_PATH) == "array" && index(REQUIRE_SEARCH_PATH[0], 'mocklib/*.uc') != -1)
+                       path = shift(REQUIRE_SEARCH_PATH);
 
-                       if (ex)
-                               die(ex);
+               try {
+                       res = require(module);
+               }
+               catch (e) {
+                       ex = e;
+               }
 
-                       return res;
-               },
+               if (path)
+                       unshift(REQUIRE_SEARCH_PATH, path);
 
-               I: (...args) => _log('info', ...args),
-               N: (...args) => _log('notice', ...args),
-               W: (...args) => _log('warn', ...args),
-               E: (...args) => _log('error', ...args),
+               if (ex)
+                       die(ex);
 
-               format_json,
-               read_data_file,
-               read_json_file,
-               trace_call
-       };
+               return res;
+       },
 
-       /* Override stdlib functions */
-       global.system = function(argv, timeout) {
-               trace_call(null, "system", { command: argv, timeout });
+       I: (...args) => _log('info', ...args),
+       N: (...args) => _log('notice', ...args),
+       W: (...args) => _log('warn', ...args),
+       E: (...args) => _log('error', ...args),
 
-               return 0;
-       };
+       format_json,
+       read_data_file,
+       read_json_file,
+       trace_call
+};
 
-       global.time = function() {
-               trace_call(null, "time");
+/* Override stdlib functions */
+global.system = function(argv, timeout) {
+       trace_call(null, "system", { command: argv, timeout });
 
-               return 1615382640;
-       };
+       return 0;
+};
 
-       global.print = function(...args) {
-               if (length(args) == 1 && type(args[0]) in ["array", "object"])
-                       printf("%s\n", format_json(args[0]));
-               else
-                       _print(...args);
-       };
+global.time = function() {
+       trace_call(null, "time");
+
+       return 1615382640;
+};
+
+global.print = function(...args) {
+       if (length(args) == 1 && type(args[0]) in ["array", "object"])
+               printf("%s\n", format_json(args[0]));
+       else
+               _print(...args);
+};
 
-       return global.mocklib;
+return global.mocklib;