@superblocksteam/sdk 2.0.74-next.2 → 2.0.75-next.3

package/test/version-control.test.mts

@@ -1,9 +1,8 @@
 import os from "node:os";
 import path from "node:path";
 import { readAppApiYamlFile, LoopType } from "@superblocksteam/util";
-import { expect } from "chai";
 import fs from "fs-extra";
-import { describe, it } from "mocha";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { stringify as ymlstringify } from "yaml";
 import { FeatureFlags } from "../src/flag.js";
 import {
@@ -43,26 +42,24 @@ const NO_EXTRACT_SOURCE_CODE: ApiRepresentation = {
   minLinesForExtraction: 0,
 };
 
-describe("version-control", function () {
+describe("version-control", () => {
   const testDir = USE_TEMP_TEST_DIR
     ? fs.mkdtempSync(path.join(os.tmpdir(), "test-output"))
     : new URL("../../test-output", import.meta.url).pathname;
 
-  // eslint-disable-next-line mocha/no-top-level-hooks
-  beforeEach(async function () {
+  beforeEach(async () => {
     // Clean up the temporary directory before each test, then create it
     await fs.rm(testDir, { recursive: true, force: true });
     await fs.ensureDir(testDir);
   });
 
-  // eslint-disable-next-line mocha/no-top-level-hooks
-  afterEach(async function () {
+  afterEach(async () => {
     // Clean up the temporary directory after each test
     await fs.rm(testDir, { recursive: true, force: true });
   });
 
-  describe("writeAppApi", function () {
-    it("should write app api to separate directory with correct name", async function () {
+  describe("writeAppApi", () => {
+    it("should write app api to separate directory with correct name", async () => {
       // Setup
       const api: ApiWrapper = {
         apiPb: {
@@ -89,8 +86,8 @@ describe("version-control", function () {
       await Promise.all(apiPromises);
 
       // Verify the ApiInfo object is correct
-      expect(apiInfo.name).to.equal("Test API");
-      expect(apiInfo.sourceFiles).to.deep.equal([]);
+      expect(apiInfo.name).toBe("Test API");
+      expect(apiInfo.sourceFiles).toEqual([]);
 
       // Verify the files exist and match expectations: one YAML file in directory nested under `apis`
       const apiDir = path.join(testDir, "apis");
@@ -100,13 +97,14 @@ describe("version-control", function () {
       await expectNoFileExists(apiDir, "test_api.yaml");
 
       // and can be read back in
-      (await readApiFile(apiDir, "Test API")).to.deep.equal({
+      const readApi = await readApiFile(apiDir, "Test API");
+      expect(readApi).toEqual({
         api: api.apiPb,
         stepPathMap: {},
       });
     });
 
-    it("should write app api to separate directory and extract large code blocks to separate files", async function () {
+    it("should write app api to separate directory and extract large code blocks to separate files", async () => {
       // Setup
       const api: ApiWrapper = {
         apiPb: {
@@ -143,23 +141,25 @@ describe("version-control", function () {
       await Promise.all(apiPromises);
 
       // Verify the ApiInfo object is correct
-      expect(apiInfo.name).to.equal("Test API");
-      expect(apiInfo.sourceFiles).to.deep.equal(["large_block.js"]);
+      expect(apiInfo.name).toBe("Test API");
+      expect(apiInfo.sourceFiles).toEqual(["large_block.js"]);
 
       // Verify the files exist and match expectations
       const apiDir = path.join(testDir, "apis");
-      (await expectFileExists(apiDir, "test_api/api.yaml")).and.contains(
-        "path: ./large_block.js",
-      );
-      (await expectFileExists(apiDir, "test_api/large_block.js")).and.includes(
-        LARGE_JS_CONTENT,
+      const apiYaml = await expectFileExists(apiDir, "test_api/api.yaml");
+      expect(apiYaml).toContain("path: ./large_block.js");
+      const jsContent = await expectFileExists(
+        apiDir,
+        "test_api/large_block.js",
       );
+      expect(jsContent).toContain(LARGE_JS_CONTENT);
 
       // And does not have a YAML file in the `apis` directory
       await expectNoFileExists(apiDir, "test_api.yaml");
 
       // and can be read back in
-      (await readApiFile(apiDir, api.apiPb.metadata.name)).to.deep.equal({
+      const readApi = await readApiFile(apiDir, api.apiPb.metadata.name);
+      expect(readApi).toEqual({
         api: api.apiPb,
         stepPathMap: {
           "Large Block": "./large_block.js",
@@ -167,7 +167,7 @@ describe("version-control", function () {
       });
     });
 
-    it("should write app api with similarly-named steps to separate directory and extract large code blocks to separate files", async function () {
+    it("should write app api with similarly-named steps to separate directory and extract large code blocks to separate files", async () => {
       const stepName1 = "Large Block";
       const stepName2 = stepName1.toLocaleLowerCase();
 
@@ -216,29 +216,27 @@ describe("version-control", function () {
       await Promise.all(apiPromises);
 
       // Verify the ApiInfo object is correct
-      expect(apiInfo.name).to.equal("Test API");
-      expect(apiInfo.sourceFiles).to.deep.equal([
+      expect(apiInfo.name).toBe("Test API");
+      expect(apiInfo.sourceFiles).toEqual([
         "large_block.js",
         "large_block_1.js",
       ]);
 
       // Verify the files exist and match expectations
       const apiDir = path.join(testDir, "apis");
-      (await expectFileExists(apiDir, "test_api/api.yaml")).and.contains(
-        "path: ./large_block.js",
-      );
-      (await expectFileExists(apiDir, "test_api/large_block.js")).and.includes(
-        LARGE_JS_CONTENT,
-      );
-      (
-        await expectFileExists(apiDir, "test_api/large_block_1.js")
-      ).and.includes(LARGER_JS_CONTENT);
+      const apiYaml = await expectFileExists(apiDir, "test_api/api.yaml");
+      expect(apiYaml).toContain("path: ./large_block.js");
+      const js1 = await expectFileExists(apiDir, "test_api/large_block.js");
+      expect(js1).toContain(LARGE_JS_CONTENT);
+      const js2 = await expectFileExists(apiDir, "test_api/large_block_1.js");
+      expect(js2).toContain(LARGER_JS_CONTENT);
 
       // And does not have a YAML file in the `apis` directory
       await expectNoFileExists(apiDir, "test_api.yaml");
 
       // and can be read back in
-      (await readApiFile(apiDir, api.apiPb.metadata.name)).to.deep.equal({
+      const readApi = await readApiFile(apiDir, api.apiPb.metadata.name);
+      expect(readApi).toEqual({
         api: api.apiPb,
         stepPathMap: {
           "Large Block": "./large_block.js",
@@ -247,7 +245,7 @@ describe("version-control", function () {
       });
     });
 
-    it("should write app api to separate directory and extract small code blocks to separate files", async function () {
+    it("should write app api to separate directory and extract small code blocks to separate files", async () => {
       // Setup
       const api: ApiWrapper = {
         apiPb: {
@@ -284,24 +282,26 @@ describe("version-control", function () {
       await Promise.all(apiPromises);
 
       // Verify the ApiInfo object is correct
-      expect(apiInfo.name).to.equal("Test API");
-      expect(apiInfo.sourceFiles).to.deep.equal(["small_block.js"]);
+      expect(apiInfo.name).toBe("Test API");
+      expect(apiInfo.sourceFiles).toEqual(["small_block.js"]);
 
       // Verify the files exist and match expectations: one YAML file in directory nested under `apis`
       const apisDir = path.join(testDir, "apis");
-      (await expectFileExists(apisDir, "test_api/api.yaml")).and.contains(
-        "path: ./small_block.js",
-      );
-      (await expectFileExists(apisDir, "test_api/small_block.js")).and.contains(
-        SMALL_JS_CONTENT,
+      const apiYaml = await expectFileExists(apisDir, "test_api/api.yaml");
+      expect(apiYaml).toContain("path: ./small_block.js");
+      const jsContent = await expectFileExists(
+        apisDir,
+        "test_api/small_block.js",
       );
+      expect(jsContent).toContain(SMALL_JS_CONTENT);
       // And no separate code file and no nested directory with the files
       await expectNoFileExists(apisDir, "small_block.js");
       await expectNoFileExists(apisDir, "test_api.yaml");
       await expectNoFileExists(apisDir, "test_api/test_api.yaml");
 
       // and can be read back in
-      (await readApiFile(apisDir, api.apiPb.metadata.name)).to.deep.equal({
+      const readApi = await readApiFile(apisDir, api.apiPb.metadata.name);
+      expect(readApi).toEqual({
         api: api.apiPb,
         stepPathMap: {
           "Small Block": "./small_block.js",
@@ -309,7 +309,7 @@ describe("version-control", function () {
       });
     });
 
-    it("should write app api to apis directory and not extract code blocks to separate files", async function () {
+    it("should write app api to apis directory and not extract code blocks to separate files", async () => {
       // Setup
       const api: ApiWrapper = {
         apiPb: {
@@ -346,8 +346,8 @@ describe("version-control", function () {
       await Promise.all(apiPromises);
 
       // Verify the ApiInfo object is correct
-      expect(apiInfo.name).to.equal("Test API");
-      expect(apiInfo.sourceFiles).to.deep.equal([]);
+      expect(apiInfo.name).toBe("Test API");
+      expect(apiInfo.sourceFiles).toEqual([]);
 
       // Compute the expected YAML file content
       const expectedYamlContent = ymlstringify(api.apiPb, {
@@ -357,21 +357,21 @@ describe("version-control", function () {
 
       // Verify the files exist and match expectations
       const apisDir = path.join(testDir, "apis");
-      (await expectFileExists(apisDir, "test_api.yaml")).and.equals(
-        expectedYamlContent,
-      );
+      const yamlContent = await expectFileExists(apisDir, "test_api.yaml");
+      expect(yamlContent).toBe(expectedYamlContent);
       await expectNoFileExists(apisDir, "large_block.js");
       await expectNoFileExists(apisDir, "test_api/test_api.yaml");
       await expectNoFileExists(apisDir, "test_api/large_block.js");
 
       // and can be read back in
-      (await readApiFile(apisDir, api.apiPb.metadata.name)).to.deep.equal({
+      const readApi = await readApiFile(apisDir, api.apiPb.metadata.name);
+      expect(readApi).toEqual({
         api: api.apiPb,
         stepPathMap: {},
       });
     });
 
-    it("should write api with try-catch, conditional, loop, and parallel JavaScript steps", async function () {
+    it("should write api with try-catch, conditional, loop, and parallel JavaScript steps", async () => {
       const api: ApiWrapper = {
         apiPb: {
           metadata: {
@@ -537,8 +537,8 @@ describe("version-control", function () {
         await Promise.all(apiPromises);
 
         // Verify the ApiInfo object is correct
-        expect(apiInfo.name).to.equal("Try Catch API");
-        expect(apiInfo.sourceFiles).to.deep.equal([
+        expect(apiInfo.name).toBe("Try Catch API");
+        expect(apiInfo.sourceFiles).toEqual([
           "else_if_step.js",
           "else_step.js",
           "if_step.js",
@@ -550,33 +550,47 @@ describe("version-control", function () {
 
         // Verify the files exist and match expectations
         const apiDir = path.join(testDir, "apis");
-        (await expectFileExists(apiDir, "try_catch_api/api.yaml")).and.contains(
-          "path: ./loop_step.js",
+        const apiYaml = await expectFileExists(
+          apiDir,
+          "try_catch_api/api.yaml",
+        );
+        expect(apiYaml).toContain("path: ./loop_step.js");
+        const loopJs = await expectFileExists(
+          apiDir,
+          "try_catch_api/loop_step.js",
+        );
+        expect(loopJs).toContain(LARGER_JS_CONTENT);
+        const secondJs = await expectFileExists(
+          apiDir,
+          "try_catch_api/second_block.js",
+        );
+        expect(secondJs).toContain(LARGE_JS_CONTENT);
+        const ifJs = await expectFileExists(apiDir, "try_catch_api/if_step.js");
+        expect(ifJs).toContain(LARGER_JS_CONTENT);
+        const elseIfJs = await expectFileExists(
+          apiDir,
+          "try_catch_api/else_if_step.js",
+        );
+        expect(elseIfJs).toContain(LARGE_JS_CONTENT);
+        const elseJs = await expectFileExists(
+          apiDir,
+          "try_catch_api/else_step.js",
+        );
+        expect(elseJs).toContain(LARGE_JS_CONTENT);
+        const path1Js = await expectFileExists(
+          apiDir,
+          "try_catch_api/path1_step.js",
         );
-        (
-          await expectFileExists(apiDir, "try_catch_api/loop_step.js")
-        ).and.includes(LARGER_JS_CONTENT);
-        (
-          await expectFileExists(apiDir, "try_catch_api/second_block.js")
-        ).and.includes(LARGE_JS_CONTENT);
-        (
-          await expectFileExists(apiDir, "try_catch_api/if_step.js")
-        ).and.includes(LARGER_JS_CONTENT);
-        (
-          await expectFileExists(apiDir, "try_catch_api/else_if_step.js")
-        ).and.includes(LARGE_JS_CONTENT);
-        (
-          await expectFileExists(apiDir, "try_catch_api/else_step.js")
-        ).and.includes(LARGE_JS_CONTENT);
-        (
-          await expectFileExists(apiDir, "try_catch_api/path1_step.js")
-        ).and.includes(LARGE_JS_CONTENT);
-        (
-          await expectFileExists(apiDir, "try_catch_api/path2_step.js")
-        ).and.includes(SMALL_JS_CONTENT);
+        expect(path1Js).toContain(LARGE_JS_CONTENT);
+        const path2Js = await expectFileExists(
+          apiDir,
+          "try_catch_api/path2_step.js",
+        );
+        expect(path2Js).toContain(SMALL_JS_CONTENT);
 
         // and can be read back in
-        (await readApiFile(apiDir, "Try Catch API")).to.deep.equal({
+        const readApi = await readApiFile(apiDir, "Try Catch API");
+        expect(readApi).toEqual({
           api: api.apiPb,
           stepPathMap: {
             "Else If Step": "./else_if_step.js",
@@ -607,14 +621,16 @@ describe("version-control", function () {
         await removeExistingFiles(existingFilePaths);
 
         // Verify the ApiInfo object is correct
-        expect(apiInfo.name).to.equal("Try Catch API");
-        expect(apiInfo.sourceFiles).to.deep.equal([]);
+        expect(apiInfo.name).toBe("Try Catch API");
+        expect(apiInfo.sourceFiles).toEqual([]);
 
         // Verify the files exist and match expectations
         const apiDir = path.join(testDir, "apis");
-        (await expectFileExists(apiDir, "try_catch_api.yaml")).and.equals(
-          expectedYamlContent,
+        const yamlContent = await expectFileExists(
+          apiDir,
+          "try_catch_api.yaml",
         );
+        expect(yamlContent).toBe(expectedYamlContent);
 
         // And no code files are created in a nested directory
         await expectNoFileExists(apiDir, "try_catch_api/api.yaml");
@@ -629,7 +645,8 @@ describe("version-control", function () {
         await expectNoFileExists(apiDir, "try_catch_api");
 
         // and can be read back in
-        (await readApiFile(apiDir, "Try Catch API")).to.deep.equal({
+        const readApi = await readApiFile(apiDir, "Try Catch API");
+        expect(readApi).toEqual({
           api: api.apiPb,
           stepPathMap: {},
         });
@@ -637,14 +654,14 @@ describe("version-control", function () {
     });
   });
 
-  describe("writeResourcesToDisk", function () {
+  describe("writeResourcesToDisk", () => {
     const mockFeatureFlags = new FeatureFlags({
       "superblocks.git.split.large.steps.enabled": true,
       "superblocks.git.split.large.steps.new.enabled": true,
       "superblocks.git.split.large.step.lines": 10,
     });
 
-    it("should write single page app to separate directory and extract code blocks to separate files", async function () {
+    it("should write single page app to separate directory and extract code blocks to separate files", async () => {
       // Setup
       const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
       const testApi: ApiWithPb = {
@@ -706,29 +723,32 @@ describe("version-control", function () {
         `${testDir}/apps/test_app`,
       )) as SuperblocksApplicationConfig;
       // Verify the apis is undefined for the new format
-      expect(config.apis).to.be.undefined;
+      expect(config.apis).toBeUndefined();
       // and the appApis is defined
-      expect(config.appApis?.[testApi.id].name).to.equal(
+      expect(config.appApis?.[testApi.id].name).toBe(
         testApi.apiPb.metadata.name,
       );
 
       // Verify the files exist and match expectations
-      expect(resourceConfig.location).to.equal("apps/test_app");
+      expect(resourceConfig.location).toBe("apps/test_app");
       await expectFileExists(testDir, "apps/test_app/application.yaml");
       await expectFileExists(testDir, "apps/test_app/page.yaml");
-      (
-        await expectFileExists(testDir, "apps/test_app/apis/test_api/api.yaml")
-      ).and.contains("path: ./large_block.js");
-      (
-        await expectFileExists(
-          testDir,
-          "apps/test_app/apis/test_api/large_block.js",
-        )
-      ).and.includes(LARGE_JS_CONTENT);
+      const apiYaml = await expectFileExists(
+        testDir,
+        "apps/test_app/apis/test_api/api.yaml",
+      );
+      expect(apiYaml).toContain("path: ./large_block.js");
+      const jsContent = await expectFileExists(
+        testDir,
+        "apps/test_app/apis/test_api/large_block.js",
+      );
+      expect(jsContent).toContain(LARGE_JS_CONTENT);
       // and can be read back in
-      (
-        await readApiFile(`${testDir}/apps/test_app/apis`, "Test API")
-      ).to.deep.equal({
+      const readApi = await readApiFile(
+        `${testDir}/apps/test_app/apis`,
+        "Test API",
+      );
+      expect(readApi).toEqual({
         api: testApi.apiPb,
         stepPathMap: {
           "Large Block": "./large_block.js",
@@ -736,7 +756,7 @@ describe("version-control", function () {
       });
     });
 
-    it("should write backend to separate directory and extract code blocks to separate files", async function () {
+    it("should write backend to separate directory and extract code blocks to separate files", async () => {
       // Setup
       const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
       const testApi: ApiWrapper = {
@@ -784,27 +804,31 @@ describe("version-control", function () {
         const config = (await expectSuperblocksJsonFileExists(
           `${testDir}/backends/test_backend`,
         )) as SuperblocksBackendConfig;
-        expect(config.sourceFiles).to.be.undefined;
+        expect(config.sourceFiles).toBeUndefined();
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("backends/test_backend");
+        expect(resourceConfig.location).toBe("backends/test_backend");
         await expectFileExists(testDir, "backends/test_backend/api.yaml");
-        (
-          await expectFileExists(testDir, "backends/test_backend/api.yaml")
-        ).and.contains(expectedYamlContent);
+        const yamlContent = await expectFileExists(
+          testDir,
+          "backends/test_backend/api.yaml",
+        );
+        expect(yamlContent).toContain(expectedYamlContent);
         await expectNoFileExists(
           testDir,
           "backends/test_backend/large_block.js",
         );
 
         // and can be read back in
-        (await readApiFile(`${testDir}/backends/test_backend`)).to.deep.equal({
+        const readApi = await readApiFile(`${testDir}/backends/test_backend`);
+        expect(readApi).toEqual({
           api: testApi.apiPb,
           stepPathMap: {},
         });
         // and a push operation would consider it valid
-        expect(await validateLocalResource(testDir, resourceConfig)).to.be
-          .undefined;
+        expect(
+          await validateLocalResource(testDir, resourceConfig),
+        ).toBeUndefined();
       }
       // Write out the backend AND extract any code blocks
       {
@@ -825,29 +849,32 @@ describe("version-control", function () {
         const config = (await expectSuperblocksJsonFileExists(
           `${testDir}/backends/test_backend`,
         )) as SuperblocksBackendConfig;
-        expect(config.sourceFiles).to.deep.equal(["large_block.js"]);
+        expect(config.sourceFiles).toEqual(["large_block.js"]);
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("backends/test_backend");
-        (
-          await expectFileExists(testDir, "backends/test_backend/api.yaml")
-        ).and.contains("path: ./large_block.js");
-        (
-          await expectFileExists(
-            testDir,
-            "backends/test_backend/large_block.js",
-          )
-        ).and.contains(LARGE_JS_CONTENT);
+        expect(resourceConfig.location).toBe("backends/test_backend");
+        const apiYaml = await expectFileExists(
+          testDir,
+          "backends/test_backend/api.yaml",
+        );
+        expect(apiYaml).toContain("path: ./large_block.js");
+        const jsContent = await expectFileExists(
+          testDir,
+          "backends/test_backend/large_block.js",
+        );
+        expect(jsContent).toContain(LARGE_JS_CONTENT);
         // and can be read back in
-        (await readApiFile(`${testDir}/backends/test_backend`)).to.deep.equal({
+        const readApi = await readApiFile(`${testDir}/backends/test_backend`);
+        expect(readApi).toEqual({
           api: testApi.apiPb,
           stepPathMap: {
             "Large Block": "./large_block.js",
           },
         });
         // and a push operation would consider it valid
-        expect(await validateLocalResource(testDir, resourceConfig)).to.be
-          .undefined;
+        expect(
+          await validateLocalResource(testDir, resourceConfig),
+        ).toBeUndefined();
       }
       // Write out the backend AGAIN without extracting any code blocks
       {
@@ -868,38 +895,42 @@ describe("version-control", function () {
         const config = (await expectSuperblocksJsonFileExists(
           `${testDir}/backends/test_backend`,
         )) as SuperblocksBackendConfig;
-        expect(config.sourceFiles).to.be.undefined;
+        expect(config.sourceFiles).toBeUndefined();
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("backends/test_backend");
+        expect(resourceConfig.location).toBe("backends/test_backend");
         await expectFileExists(testDir, "backends/test_backend/api.yaml");
-        (
-          await expectFileExists(testDir, "backends/test_backend/api.yaml")
-        ).and.contains(expectedYamlContent);
+        const yamlContent = await expectFileExists(
+          testDir,
+          "backends/test_backend/api.yaml",
+        );
+        expect(yamlContent).toContain(expectedYamlContent);
         await expectNoFileExists(
           testDir,
           "backends/test_backend/large_block.js",
         );
         // and can be read back in
-        (await readApiFile(`${testDir}/backends/test_backend`)).to.deep.equal({
+        const readApi = await readApiFile(`${testDir}/backends/test_backend`);
+        expect(readApi).toEqual({
           api: testApi.apiPb,
           stepPathMap: {},
         });
         // and a push operation would consider it valid
-        expect(await validateLocalResource(testDir, resourceConfig)).to.be
-          .undefined;
+        expect(
+          await validateLocalResource(testDir, resourceConfig),
+        ).toBeUndefined();
       }
     });
   });
 
-  describe("writeApplicationToDIsk", function () {
+  describe("writeApplicationToDIsk", () => {
     const mockFeatureFlags = new FeatureFlags({
       "superblocks.git.split.large.steps.enabled": true,
       "superblocks.git.split.large.steps.new.enabled": false,
       "superblocks.git.split.large.step.lines": 10,
     });
 
-    it("should write multi-pageapp to disk", async function () {
+    it("should write multi-pageapp to disk", async () => {
       // Setup
       const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
       const testApi: ApiWithPb = {
@@ -961,30 +992,28 @@ describe("version-control", function () {
         `${testDir}/apps/test_app/`,
       )) as SuperblocksApplicationConfig;
       const page = config.pages?.[multiPageApp.pages[0].id];
-      expect(page?.apis).to.be.undefined;
-      expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+      expect(page?.apis).toBeUndefined();
+      expect(page?.pageApis?.[testApi.id]?.sourceFiles).toEqual([
         "large_block.js",
       ]);
 
       // Verify the files exist and match expectations
-      expect(resourceConfig.location).to.equal("apps/test_app");
+      expect(resourceConfig.location).toBe("apps/test_app");
       await expectFileExists(testDir, "apps/test_app/application.yaml");
       await expectFileExists(
         testDir,
         "apps/test_app/pages/test_page/page.yaml",
       );
-      (
-        await expectFileExists(
-          testDir,
-          "apps/test_app/pages/test_page/apis/test_api/api.yaml",
-        )
-      ).and.includes("path: ./large_block.js");
-      (
-        await expectFileExists(
-          testDir,
-          "apps/test_app/pages/test_page/apis/test_api/large_block.js",
-        )
-      ).and.includes(LARGE_JS_CONTENT);
+      const apiYaml = await expectFileExists(
+        testDir,
+        "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+      );
+      expect(apiYaml).toContain("path: ./large_block.js");
+      const jsContent = await expectFileExists(
+        testDir,
+        "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+      );
+      expect(jsContent).toContain(LARGE_JS_CONTENT);
 
       // and does not have the files in the old format
       await expectNoFileExists(
@@ -997,23 +1026,23 @@ describe("version-control", function () {
       );
 
       // and can be read back in
-      (
-        await readApiFile(
-          `${testDir}/apps/test_app/pages/test_page/apis`,
-          "Test API",
-        )
-      ).to.deep.equal({
+      const readApi = await readApiFile(
+        `${testDir}/apps/test_app/pages/test_page/apis`,
+        "Test API",
+      );
+      expect(readApi).toEqual({
         api: testApi.apiPb,
         stepPathMap: {
           "Large Block": "./large_block.js",
         },
       });
       // and a push operation would consider it valid
-      expect(await validateLocalResource(testDir, resourceConfig)).to.be
-        .undefined;
+      expect(
+        await validateLocalResource(testDir, resourceConfig),
+      ).toBeUndefined();
     });
 
-    it("should write multi-pageapp to disk and overwrite existing files", async function () {
+    it("should write multi-pageapp to disk and overwrite existing files", async () => {
       // Setup
       const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
       const testApi: ApiWithPb = {
@@ -1082,37 +1111,36 @@ describe("version-control", function () {
           `${testDir}/apps/test_app/`,
         )) as SuperblocksApplicationConfig;
         const page = config.pages?.[multiPageApp.pages[0].id];
-        expect(page?.pageApis).to.be.undefined;
-        expect(page?.apis).to.be.deep.equal({ "test-id": "Test API" });
+        expect(page?.pageApis).toBeUndefined();
+        expect(page?.apis).toEqual({ "test-id": "Test API" });
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("apps/test_app");
+        expect(resourceConfig.location).toBe("apps/test_app");
         await expectFileExists(testDir, "apps/test_app/application.yaml");
         await expectFileExists(
           testDir,
           "apps/test_app/pages/test_page/page.yaml",
         );
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api.yaml",
-          )
-        ).and.contains(expectedYamlContent);
+        const yamlContent = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api.yaml",
+        );
+        expect(yamlContent).toContain(expectedYamlContent);
         // And does not have the source code extracted
         await expectNoFileExists(
           testDir,
           "apps/test_app/pages/test_page/apis/test_api/large_block.js",
         );
         // and can be read back in
-        (
-          await readApiFile(
-            `${testDir}/apps/test_app/pages/test_page/apis`,
-            "Test API",
-          )
-        ).to.deep.equal({ api: testApi.apiPb, stepPathMap: {} });
+        const readApi = await readApiFile(
+          `${testDir}/apps/test_app/pages/test_page/apis`,
+          "Test API",
+        );
+        expect(readApi).toEqual({ api: testApi.apiPb, stepPathMap: {} });
         // and a push operation would consider it valid
-        expect(await validateLocalResource(testDir, resourceConfig)).to.be
-          .undefined;
+        expect(
+          await validateLocalResource(testDir, resourceConfig),
+        ).toBeUndefined();
       }
 
       // Write out the same multi-page app again, but this time extract any code blocks
@@ -1132,30 +1160,28 @@ describe("version-control", function () {
           `${testDir}/apps/test_app/`,
         )) as SuperblocksApplicationConfig;
         const page = config.pages?.[multiPageApp.pages[0].id];
-        expect(page?.apis).to.be.undefined;
-        expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+        expect(page?.apis).toBeUndefined();
+        expect(page?.pageApis?.[testApi.id]?.sourceFiles).toEqual([
           "large_block.js",
         ]);
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("apps/test_app");
+        expect(resourceConfig.location).toBe("apps/test_app");
         await expectFileExists(testDir, "apps/test_app/application.yaml");
         await expectFileExists(
           testDir,
           "apps/test_app/pages/test_page/page.yaml",
         );
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api/api.yaml",
-          )
-        ).and.contains("path: ./large_block.js");
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api/large_block.js",
-          )
-        ).and.includes(LARGE_JS_CONTENT);
+        const apiYaml = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+        );
+        expect(apiYaml).toContain("path: ./large_block.js");
+        const jsContent = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+        );
+        expect(jsContent).toContain(LARGE_JS_CONTENT);
         // And the old file no longer exists
         await expectNoFileExists(
           testDir,
@@ -1166,20 +1192,20 @@ describe("version-control", function () {
           "apps/test_app/pages/test_page/apis/test_api/test_api.yaml",
         );
         // and can be read back in
-        (
-          await readApiFile(
-            `${testDir}/apps/test_app/pages/test_page/apis`,
-            "Test API",
-          )
-        ).to.deep.equal({
+        const readApi = await readApiFile(
+          `${testDir}/apps/test_app/pages/test_page/apis`,
+          "Test API",
+        );
+        expect(readApi).toEqual({
           api: testApi.apiPb,
           stepPathMap: {
             "Large Block": "./large_block.js",
           },
         });
         // and a push operation would consider it valid
-        expect(await validateLocalResource(testDir, resourceConfig)).to.be
-          .undefined;
+        expect(
+          await validateLocalResource(testDir, resourceConfig),
+        ).toBeUndefined();
       }
 
       // Write out the same multi-page app again, but this time with shorter code that should be extracted
@@ -1203,51 +1229,49 @@ describe("version-control", function () {
           `${testDir}/apps/test_app/`,
         )) as SuperblocksApplicationConfig;
         const page = config.pages?.[multiPageApp.pages[0].id];
-        expect(page?.apis).to.be.undefined;
-        expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+        expect(page?.apis).toBeUndefined();
+        expect(page?.pageApis?.[testApi.id]?.sourceFiles).toEqual([
           "large_block.js",
         ]);
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("apps/test_app");
+        expect(resourceConfig.location).toBe("apps/test_app");
         await expectFileExists(testDir, "apps/test_app/application.yaml");
         await expectFileExists(
           testDir,
           "apps/test_app/pages/test_page/page.yaml",
         );
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api/api.yaml",
-          )
-        ).and.contains("path: ./large_block.js");
+        const apiYaml = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+        );
+        expect(apiYaml).toContain("path: ./large_block.js");
         // And does have the source code extracted
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api/large_block.js",
-          )
-        ).and.includes(SMALL_JS_CONTENT);
+        const jsContent = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+        );
+        expect(jsContent).toContain(SMALL_JS_CONTENT);
         // And does not have the old file
         await expectNoFileExists(
           testDir,
           "apps/test_app/pages/test_page/apis/test_api.yaml",
         );
         // and can be read back in
-        (
-          await readApiFile(
-            `${testDir}/apps/test_app/pages/test_page/apis`,
-            "Test API",
-          )
-        ).to.deep.equal({
+        const readApi = await readApiFile(
+          `${testDir}/apps/test_app/pages/test_page/apis`,
+          "Test API",
+        );
+        expect(readApi).toEqual({
           api: testApi.apiPb,
           stepPathMap: {
             "Large Block": "./large_block.js",
           },
         });
         // and a push operation would consider it valid
-        expect(await validateLocalResource(testDir, resourceConfig)).to.be
-          .undefined;
+        expect(
+          await validateLocalResource(testDir, resourceConfig),
+        ).toBeUndefined();
       }
 
       // Write out the same multi-page app again, again with large code so files are extracted
@@ -1271,30 +1295,28 @@ describe("version-control", function () {
           `${testDir}/apps/test_app/`,
         )) as SuperblocksApplicationConfig;
         const page = config.pages?.[multiPageApp.pages[0].id];
-        expect(page?.apis).to.be.undefined;
-        expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+        expect(page?.apis).toBeUndefined();
+        expect(page?.pageApis?.[testApi.id]?.sourceFiles).toEqual([
           "large_block.js",
         ]);
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("apps/test_app");
+        expect(resourceConfig.location).toBe("apps/test_app");
         await expectFileExists(testDir, "apps/test_app/application.yaml");
         await expectFileExists(
           testDir,
           "apps/test_app/pages/test_page/page.yaml",
         );
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api/api.yaml",
-          )
-        ).and.contains("path: ./large_block.js");
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api/large_block.js",
-          )
-        ).and.includes(LARGE_JS_CONTENT);
+        const apiYaml = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+        );
+        expect(apiYaml).toContain("path: ./large_block.js");
+        const jsContent = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+        );
+        expect(jsContent).toContain(LARGE_JS_CONTENT);
         // And the old file no longer exists
         await expectNoFileExists(
           testDir,
@@ -1306,20 +1328,20 @@ describe("version-control", function () {
           "apps/test_app/pages/test_page/apis/test_api/test_api.yaml",
         );
         // and can be read back in
-        (
-          await readApiFile(
-            `${testDir}/apps/test_app/pages/test_page/apis`,
-            "Test API",
-          )
-        ).to.deep.equal({
+        const readApi = await readApiFile(
+          `${testDir}/apps/test_app/pages/test_page/apis`,
+          "Test API",
+        );
+        expect(readApi).toEqual({
           api: testApi.apiPb,
           stepPathMap: {
             "Large Block": "./large_block.js",
           },
         });
         // and a push operation would consider it valid
-        expect(await validateLocalResource(testDir, resourceConfig)).to.be
-          .undefined;
+        expect(
+          await validateLocalResource(testDir, resourceConfig),
+        ).toBeUndefined();
       }
 
       // Write out the multi-page app again without extracting any code blocks
@@ -1341,30 +1363,28 @@ describe("version-control", function () {
         });
 
         // Verify the files exist and match expectations
-        expect(resourceConfig.location).to.equal("apps/test_app");
+        expect(resourceConfig.location).toBe("apps/test_app");
         await expectFileExists(testDir, "apps/test_app/application.yaml");
         await expectFileExists(
           testDir,
           "apps/test_app/pages/test_page/page.yaml",
         );
-        (
-          await expectFileExists(
-            testDir,
-            "apps/test_app/pages/test_page/apis/test_api.yaml",
-          )
-        ).and.contains(expectedYamlContent);
+        const yamlContent = await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api.yaml",
+        );
+        expect(yamlContent).toContain(expectedYamlContent);
         // And does not have the source code extracted
         await expectNoFileExists(
           testDir,
           "apps/test_app/pages/test_page/apis/test_api/large_block.js",
         );
         // and can be read back in
-        (
-          await readApiFile(
-            `${testDir}/apps/test_app/pages/test_page/apis`,
-            "Test API",
-          )
-        ).to.deep.equal({
+        const readApi = await readApiFile(
+          `${testDir}/apps/test_app/pages/test_page/apis`,
+          "Test API",
+        );
+        expect(readApi).toEqual({
           api: testApi.apiPb,
           stepPathMap: {},
         });
@@ -1376,31 +1396,28 @@ describe("version-control", function () {
 async function expectFileExists(
   testDir: string,
   relativePath: string,
-): Promise<Chai.Assertion> {
+): Promise<string> {
   const filePath = path.join(testDir, relativePath);
-  await expect(await fs.pathExists(filePath)).to.be.true;
+  expect(await fs.pathExists(filePath)).toBe(true);
   const content = await fs.readFile(filePath, "utf8");
-  return expect(content);
+  return content;
 }
 
 async function expectNoFileExists(testDir: string, relativePath: string) {
   const filePath = path.join(testDir, relativePath);
-  expect(await fs.pathExists(filePath)).to.be.false;
+  expect(await fs.pathExists(filePath)).toBe(false);
 }
 
-async function readApiFile(
-  testDir: string,
-  apiName?: string,
-): Promise<Chai.Assertion> {
+async function readApiFile(testDir: string, apiName?: string) {
   const api = await readAppApiYamlFile(testDir, apiName);
-  return expect(api);
+  return api;
 }
 
 async function expectSuperblocksJsonFileExists(
   testDir: string,
 ): Promise<SuperblocksConfig> {
   const filePath = path.join(testDir, ".superblocks/superblocks.json");
-  await expect(await fs.pathExists(filePath)).to.be.true;
+  expect(await fs.pathExists(filePath)).toBe(true);
   const content = await fs.readFile(filePath, "utf8");
   return JSON.parse(content) as SuperblocksConfig;
 }