debugger/src/utils/pause/scopes/tests/scopes.spec.js at shadowed-objects · JavaScript-Developer-VSM/debugger · 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
111
112
113
114
115
116
117
118
119
120
121
122
123
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */

// @flow

import { getScopes } from "..";
import {
  makeMockFrame,
  makeMockScope,
  makeWhyNormal,
  makeWhyThrow,
  mockScopeAddVariable
} from "../../../test-mockup";

import type { Scope } from "../../../../types";
import type { RenderableScope } from "../getScope";

function convertScope(scope: Scope): RenderableScope {
  return (scope: any);
}

describe("scopes", () => {
  describe("getScopes", () => {
    it("single scope", () => {
      const pauseData = makeWhyNormal();
      const scope = makeMockScope("actor1");
      const selectedFrame = makeMockFrame(undefined, undefined, scope);

      const frameScopes = convertScope(selectedFrame.scope);
      const scopes = getScopes(pauseData, selectedFrame, frameScopes);
      if (!scopes) {
        throw new Error("missing scopes");
      }
      expect(scopes[0].path).toEqual("actor1-1");
      expect(scopes[0].contents[0]).toEqual({
        name: "<this>",
        path: "actor1-1/<this>",
        contents: { value: {} }
      });
    });

    it("second scope", () => {
      const pauseData = makeWhyNormal();
      const scope0 = makeMockScope("actor2");
      const scope1 = makeMockScope("actor1", undefined, scope0);
      const selectedFrame = makeMockFrame(undefined, undefined, scope1);
      mockScopeAddVariable(scope0, "foo");

      const frameScopes = convertScope(selectedFrame.scope);
      const scopes = getScopes(pauseData, selectedFrame, frameScopes);
      if (!scopes) {
        throw new Error("missing scopes");
      }
      expect(scopes[1].path).toEqual("actor2-2");
      expect(scopes[1].contents[0]).toEqual({
        name: "foo",
        path: "actor2-2/foo",
        contents: { value: null }
      });
    });

    it("returning scope", () => {
      const why = makeWhyNormal("to sender");
      const scope = makeMockScope("actor1");
      const selectedFrame = makeMockFrame(undefined, undefined, scope);

      const frameScopes = convertScope(selectedFrame.scope);
      const scopes = getScopes(why, selectedFrame, frameScopes);
      expect(scopes).toMatchObject([
        {
          path: "actor1-1",
          contents: [
            {
              name: "<return>",
              path: "actor1-1/<return>",
              contents: {
                value: "to sender"
              }
            },
            {
              name: "<this>",
              path: "actor1-1/<this>",
              contents: {
                value: {}
              }
            }
          ]
        }
      ]);
    });

    it("throwing scope", () => {
      const why = makeWhyThrow("a party");
      const scope = makeMockScope("actor1");
      const selectedFrame = makeMockFrame(undefined, undefined, scope);

      const frameScopes = convertScope(selectedFrame.scope);
      const scopes = getScopes(why, selectedFrame, frameScopes);
      expect(scopes).toMatchObject([
        {
          path: "actor1-1",
          contents: [
            {
              name: "<exception>",
              path: "actor1-1/<exception>",
              contents: {
                value: "a party"
              }
            },
            {
              name: "<this>",
              path: "actor1-1/<this>",
              contents: {
                value: {}
              }
            }
          ]
        }
      ]);
    });
  });
});