all repos — sz-chrome-remote-cdp @ master

pi-browser-harness, patched to drive a Chrome on another host over CDP, with castle_cdp_search web search

test/util/guards-test.ts (view raw)

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 
import { test, describe } from "node:test";
import assert from "node:assert/strict";
import { asArrayOf, asBoolean, asNumber, asRecord, asString, errnoCode, isRecord } from "../../src/util/guards";

describe("isRecord", () => {
  test("accepts plain objects", () => {
    assert.equal(isRecord({}), true);
    assert.equal(isRecord({ a: 1 }), true);
  });

  test("rejects null, arrays and primitives", () => {
    assert.equal(isRecord(null), false);
    assert.equal(isRecord(undefined), false);
    assert.equal(isRecord([]), false);
    assert.equal(isRecord([{ a: 1 }]), false);
    assert.equal(isRecord("s"), false);
    assert.equal(isRecord(0), false);
    assert.equal(isRecord(false), false);
  });
});

describe("scalar readers", () => {
  test("asString accepts only strings", () => {
    assert.equal(asString(""), "");
    assert.equal(asString("x"), "x");
    assert.equal(asString(1), undefined);
    assert.equal(asString(null), undefined);
    assert.equal(asString(undefined), undefined);
    assert.equal(asString({}), undefined);
  });

  test("asNumber accepts only numbers, including 0 and NaN", () => {
    assert.equal(asNumber(0), 0);
    assert.equal(asNumber(-1.5), -1.5);
    assert.equal(Number.isNaN(asNumber(Number.NaN)), true);
    assert.equal(asNumber("1"), undefined);
    assert.equal(asNumber(null), undefined);
  });

  test("asBoolean accepts only booleans", () => {
    assert.equal(asBoolean(false), false);
    assert.equal(asBoolean(true), true);
    assert.equal(asBoolean(0), undefined);
    assert.equal(asBoolean("true"), undefined);
  });

  test("asRecord mirrors isRecord but yields the value", () => {
    assert.deepEqual(asRecord({ a: 1 }), { a: 1 });
    assert.equal(asRecord([]), undefined);
    assert.equal(asRecord(null), undefined);
  });
});

describe("asArrayOf", () => {
  test("parses every element", () => {
    assert.deepEqual(asArrayOf(["a", "b"], asString), ["a", "b"]);
    assert.deepEqual(asArrayOf([], asString), []);
  });

  test("rejects the whole array when any element fails, rather than dropping it", () => {
    assert.equal(asArrayOf(["a", 2], asString), undefined);
    assert.equal(asArrayOf([1, "b"], asString), undefined);
  });

  test("rejects non-arrays", () => {
    assert.equal(asArrayOf({ 0: "a" }, asString), undefined);
    assert.equal(asArrayOf(undefined, asString), undefined);
    assert.equal(asArrayOf("ab", asString), undefined);
  });

  test("treats an element parsed as undefined as a failure", () => {
    assert.equal(asArrayOf([undefined], asString), undefined);
  });
});

describe("errnoCode", () => {
  test("reads .code off a real Error", () => {
    const e = Object.assign(new Error("nope"), { code: "ENOENT" });
    assert.equal(errnoCode(e), "ENOENT");
  });

  test("returns undefined for an Error without a code", () => {
    assert.equal(errnoCode(new Error("plain")), undefined);
  });

  test("returns undefined for a non-string code", () => {
    assert.equal(errnoCode(Object.assign(new Error("x"), { code: 13 })), undefined);
  });

  test("returns undefined for non-Errors that merely carry a code", () => {
    assert.equal(errnoCode({ code: "ENOENT" }), undefined);
    assert.equal(errnoCode("ENOENT"), undefined);
    assert.equal(errnoCode(null), undefined);
  });
});