racp/src/api/rathena/ScriptRepository.test.ts at main · kasper573/racp · GitHub

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
96
97
98
99
100
101
102
import { expect } from "@jest/globals";
import { parseTextEntities, replaceScripts } from "./ScriptRepository";

describe("parseTextEntities", () => {
  describe("can parse", () => {
    it("multiple entities", () => {
      const entities = parseTextEntities(`
tightly,1\tfoo
stacked,2\tbar
entities,3\tbaz
      `);

      expect(entities).toEqual([
        [["tightly", "1"], ["foo"]],
        [["stacked", "2"], ["bar"]],
        [["entities", "3"], ["baz"]],
      ]);
    });

    it("leading empty value", () => {
      const entities = parseTextEntities(`,foo`);
      expect(entities).toEqual([[["", "foo"]]]);
    });

    it("trailing empty value", () => {
      const entities = parseTextEntities(`foo,`);
      expect(entities).toEqual([[["foo", ""]]]);
    });

    it("leading empty part", () => {
      const entities = parseTextEntities(`\tfoo`);
      expect(entities).toEqual([[[""], ["foo"]]]);
    });

    it("trailing empty part", () => {
      const entities = parseTextEntities(`foo\t`);
      expect(entities).toEqual([[["foo"], [""]]]);
    });

    describe("scripts", () => {
      it("at the start", () => {
        const entities = parseTextEntities(`${mockScript()},after`);
        expect(entities).toEqual([[[mockScript(), "after"]]]);
      });

      it("in the middle", () => {
        const entities = parseTextEntities(`before,${mockScript()},after`);
        expect(entities).toEqual([[["before", mockScript(), "after"]]]);
      });

      it("at the end", () => {
        const entities = parseTextEntities(`before,${mockScript()}`);
        expect(entities).toEqual([[["before", mockScript()]]]);
      });

      it("in a row", () => {
        const entities = parseTextEntities(`
script1,${mockScript(1)}
script2,${mockScript(2)}
script3,${mockScript(3)}
      `);

        expect(entities).toEqual([
          [["script1", mockScript(1)]],
          [["script2", mockScript(2)]],
          [["script3", mockScript(3)]],
        ]);
      });
    });
  });

  it("can ignore comments / empty whitespace lines", () => {
    const comment = "// comment";
    const entities = parseTextEntities(`
${comment}

foo,1

bar,2
    `);

    const entitiesAsString = JSON.stringify(entities);
    expect(entitiesAsString).not.toMatch(/[\n\s]/);
    expect(entitiesAsString).not.toEqual(expect.stringContaining(comment));
  });

  it("can replace scripts", () => {
    const wrap = (script: string) => `before ${script} after`;
    const id = "[placeholder]";
    const result = replaceScripts(wrap(mockScript()), () => id);
    expect(result).toEqual({
      text: wrap(id),
      scripts: { [id]: mockScript() },
    });
  });
});

const mockScript = (seed?: number) => `{
  {
    test("script${seed ?? ""}")
  }
}`;