feat: introduce APIs to update envs from tests and recursive resolution

packages/hoppscotch-js-sandbox/src/__tests__/testing/envs/get.spec.ts

@@ -0,0 +1,178 @@
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { execTestScript, TestResponse, TestResult } from "../../../test-runner"
+
+import "@relmify/jest-fp-ts"
+
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    execTestScript(script, envs, fakeResponse),
+    TE.map((x) => x.tests)
+  )
+
+describe("pw.env.get", () => {
+  test("returns the correct value for an existing selected environment value", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.get("a")
+          pw.expect(data).toBe("b")
+      `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              value: "b",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'b' to be 'b'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns the correct value for an existing global environment value", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.get("a")
+          pw.expect(data).toBe("b")
+      `,
+        {
+          global: [
+            {
+              key: "a",
+              value: "b",
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'b' to be 'b'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns undefined for a key that is not present in both selected or environment", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.get("a")
+          pw.expect(data).toBe(undefined)
+      `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'undefined' to be 'undefined'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns the value defined in selected environment if it is also present in global", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.get("a")
+          pw.expect(data).toBe("selected val")
+      `,
+        {
+          global: [
+            {
+              key: "a",
+              value: "global val",
+            },
+          ],
+          selected: [
+            {
+              key: "a",
+              value: "selected val",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'selected val' to be 'selected val'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("does not resolve environment values", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.get("a")
+          pw.expect(data).toBe("<<hello>>")
+      `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              value: "<<hello>>",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected '<<hello>>' to be '<<hello>>'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if the key is not a string", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.get(5)
+      `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+})

packages/hoppscotch-js-sandbox/src/__tests__/testing/envs/getResolve.spec.ts

@@ -0,0 +1,219 @@
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { execTestScript, TestResponse, TestResult } from "../../../test-runner"
+
+import "@relmify/jest-fp-ts"
+
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    execTestScript(script, envs, fakeResponse),
+    TE.map((x) => x.tests),
+    TE.mapLeft((x) => {
+      console.log(x)
+      return x
+    })
+  )
+
+describe("pw.env.getResolve", () => {
+  test("returns the correct value for an existing selected environment value", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.getResolve("a")
+          pw.expect(data).toBe("b")
+      `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              value: "b",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'b' to be 'b'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns the correct value for an existing global environment value", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.getResolve("a")
+          pw.expect(data).toBe("b")
+      `,
+        {
+          global: [
+            {
+              key: "a",
+              value: "b",
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'b' to be 'b'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns undefined for a key that is not present in both selected or environment", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.getResolve("a")
+          pw.expect(data).toBe(undefined)
+      `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'undefined' to be 'undefined'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns the value defined in selected environment if it is also present in global", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.getResolve("a")
+          pw.expect(data).toBe("selected val")
+      `,
+        {
+          global: [
+            {
+              key: "a",
+              value: "global val",
+            },
+          ],
+          selected: [
+            {
+              key: "a",
+              value: "selected val",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'selected val' to be 'selected val'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("resolve environment values", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.getResolve("a")
+          pw.expect(data).toBe("there")
+      `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              value: "<<hello>>",
+            },
+            {
+              key: "hello",
+              value: "there",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'there' to be 'there'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns unresolved value on infinite loop in resolution", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.getResolve("a")
+          pw.expect(data).toBe("<<hello>>")
+      `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              value: "<<hello>>",
+            },
+            {
+              key: "hello",
+              value: "<<a>>",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected '<<hello>>' to be '<<hello>>'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if the key is not a string", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.getResolve(5)
+      `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+})

packages/hoppscotch-js-sandbox/src/__tests__/testing/envs/resolve.spec.ts

@@ -0,0 +1,156 @@
+import { pipe } from "fp-ts/function"
+import * as TE from "fp-ts/TaskEither"
+import { execTestScript, TestResponse, TestResult } from "../../../test-runner"
+
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    execTestScript(script, envs, fakeResponse),
+    TE.map((x) => x.tests)
+  )
+
+describe("pw.env.resolve", () => {
+  test("value should be a string", () => {
+    return expect(
+      func(
+        `
+          pw.env.resolve(5)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("resolves global variables correctly", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.resolve("<<hello>>")
+          pw.expect(data).toBe("there")
+        `,
+        {
+          global: [
+            {
+              key: "hello",
+              value: "there",
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'there' to be 'there'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("resolves selected env variables correctly", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.resolve("<<hello>>")
+          pw.expect(data).toBe("there")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "hello",
+              value: "there",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'there' to be 'there'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("chooses selected env variable over global variables when both have same variable", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.resolve("<<hello>>")
+          pw.expect(data).toBe("there")
+        `,
+        {
+          global: [
+            {
+              key: "hello",
+              value: "yo",
+            },
+          ],
+          selected: [
+            {
+              key: "hello",
+              value: "there",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'there' to be 'there'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("if infinite loop in resolution, abandons resolutions altogether", () => {
+    return expect(
+      func(
+        `
+          const data = pw.env.resolve("<<hello>>")
+          pw.expect(data).toBe("<<hello>>")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "hello",
+              value: "<<there>>",
+            },
+            {
+              key: "there",
+              value: "<<hello>>",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected '<<hello>>' to be '<<hello>>'",
+          },
+        ],
+      }),
+    ])
+  })
+})

packages/hoppscotch-js-sandbox/src/__tests__/testing/envs/set.spec.ts

@@ -0,0 +1,208 @@
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { execTestScript, TestResponse, TestResult } from "../../../test-runner"
+
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    execTestScript(script, envs, fakeResponse),
+    TE.map((x) => x.envs)
+  )
+
+const funcTest = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    execTestScript(script, envs, fakeResponse),
+    TE.map((x) => x.tests)
+  )
+
+describe("pw.env.set", () => {
+  test("updates the selected environment variable correctly", () => {
+    return expect(
+      func(
+        `
+          pw.env.set("a", "c")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              value: "b",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "a",
+            value: "c",
+          },
+        ],
+      })
+    )
+  })
+
+  test("updates the global environment variable correctly", () => {
+    return expect(
+      func(
+        `
+          pw.env.set("a", "c")
+        `,
+        {
+          global: [
+            {
+              key: "a",
+              value: "b",
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "a",
+            value: "c",
+          },
+        ],
+      })
+    )
+  })
+
+  test("updates the selected environment if env present in both", () => {
+    return expect(
+      func(
+        `
+          pw.env.set("a", "c")
+        `,
+        {
+          global: [
+            {
+              key: "a",
+              value: "b",
+            },
+          ],
+          selected: [
+            {
+              key: "a",
+              value: "d",
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "a",
+            value: "b",
+          },
+        ],
+        selected: [
+          {
+            key: "a",
+            value: "c",
+          },
+        ],
+      })
+    )
+  })
+
+  test("non existent keys are created in the selected environment", () => {
+    return expect(
+      func(
+        `
+          pw.env.set("a", "c")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [],
+        selected: [
+          {
+            key: "a",
+            value: "c",
+          },
+        ],
+      })
+    )
+  })
+
+  test("keys should be a string", () => {
+    return expect(
+      func(
+        `
+          pw.env.set(5, "c")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("values should be a string", () => {
+    return expect(
+      func(
+        `
+          pw.env.set("a", 5)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("both keys and values should be strings", () => {
+    return expect(
+      func(
+        `
+          pw.env.set(5, 5)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("set environment values are reflected in the script execution", () => {
+    return expect(
+      funcTest(
+        `
+          pw.env.set("a", "b")
+          pw.expect(pw.env.get("a")).toBe("b")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'b' to be 'b'",
+          },
+        ],
+      }),
+    ])
+  })
+})