sdk/__tests__\service.test.ts at 955e6777e7669e109d8b070f7401dde867ee8583 · sorosave-protocol/sdk · 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
103
104
105
106
107
108
109
110
import { WebhookService } from "../service";

describe("WebhookService", () => {
  let service: WebhookService;

  beforeEach(() => {
    service = new WebhookService({ maxRetries: 1, retryDelay: 10 });
  });

  describe("register", () => {
    it("registers a valid webhook", () => {
      const wh = service.register({
        url: "https://example.com/hook",
        events: ["group.created"],
        secret: "supersecretkey",
      });
      expect(wh.id).toBeDefined();
      expect(wh.active).toBe(true);
    });

    it("throws for an invalid URL", () => {
      expect(() =>
        service.register({
          url: "not-a-url",
          events: ["group.created"],
          secret: "supersecretkey",
        })
      ).toThrow("Invalid webhook URL");
    });

    it("throws for empty events array", () => {
      expect(() =>
        service.register({
          url: "https://example.com/hook",
          events: [],
          secret: "supersecretkey",
        })
      ).toThrow("At least one event type");
    });

    it("throws for a secret shorter than 8 characters", () => {
      expect(() =>
        service.register({
          url: "https://example.com/hook",
          events: ["group.created"],
          secret: "short",
        })
      ).toThrow("Secret must be at least 8 characters");
    });
  });

  describe("list / get / delete", () => {
    it("lists registered webhooks", () => {
      service.register({
        url: "https://example.com/hook",
        events: ["group.created"],
        secret: "supersecretkey",
      });
      expect(service.list()).toHaveLength(1);
    });

    it("gets a webhook by ID", () => {
      const wh = service.register({
        url: "https://example.com/hook",
        events: ["group.created"],
        secret: "supersecretkey",
      });
      expect(service.get(wh.id)).toEqual(wh);
    });

    it("deletes a webhook", () => {
      const wh = service.register({
        url: "https://example.com/hook",
        events: ["group.created"],
        secret: "supersecretkey",
      });
      expect(service.delete(wh.id)).toBe(true);
      expect(service.get(wh.id)).toBeUndefined();
    });
  });

  describe("dispatch", () => {
    it("returns empty array when no webhooks are registered", async () => {
      const results = await service.dispatch("group.created", { groupId: 1 });
      expect(results).toHaveLength(0);
    });

    it("delivers to matching webhooks and records failure for unreachable URLs", async () => {
      service.register({
        url: "http://localhost:19999/unreachable",
        events: ["group.created"],
        secret: "supersecretkey",
      });
      const results = await service.dispatch("group.created", { groupId: 1 });
      expect(results).toHaveLength(1);
      expect(results[0].success).toBe(false);
      expect(results[0].attempts).toBeGreaterThanOrEqual(1);
    });

    it("does not deliver to webhooks not subscribed to the event", async () => {
      service.register({
        url: "https://example.com/hook",
        events: ["group.payout"],
        secret: "supersecretkey",
      });
      const results = await service.dispatch("group.created", { groupId: 1 });
      expect(results).toHaveLength(0);
    });
  });
});