@superblocksteam/sdk 2.0.75-next.3 → 2.0.75

package/test/version-control.test.mts

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