revive/js/tests/node.test.mjs

import { expect } from "chai";
import { compile } from "../examples/node/revive.js";
import { fileURLToPath } from "url";
import path from "path";
import fs from "fs";
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

function loadFixture(fixture) {
  const fixturePath = path.resolve(__dirname, `../fixtures/${fixture}`);
  return JSON.parse(fs.readFileSync(fixturePath, "utf-8"));
}

describe("Compile Function Tests", function () {
  it("should successfully compile valid Solidity code", async function () {
    const standardInput = loadFixture("storage.json");

    const result = await compile(standardInput);
    expect(result).to.be.a("string");
    const output = JSON.parse(result);
    expect(output).to.have.property("contracts");
    expect(output.contracts["fixtures/storage.sol"]).to.have.property(
      "Storage",
    );
    expect(output.contracts["fixtures/storage.sol"].Storage).to.have.property(
      "abi",
    );
    expect(output.contracts["fixtures/storage.sol"].Storage).to.have.property(
      "evm",
    );
    expect(
      output.contracts["fixtures/storage.sol"].Storage.evm,
    ).to.have.property("bytecode");
  });

  if (typeof globalThis.Bun == "undefined") {
    // Running this test with Bun on a Linux host causes:
    // RuntimeError: Out of bounds memory access (evaluating 'getWasmTableEntry(index)(a1, a2, a3, a4, a5)')
    // Once this issue is resolved, the test will be re-enabled.
    it("should successfully compile large Solidity code", async function () {
      const standardInput = loadFixture("token.json");

      const result = await compile(standardInput);
      expect(result).to.be.a("string");
      const output = JSON.parse(result);
      expect(output).to.have.property("contracts");
      expect(output.contracts["fixtures/token.sol"]).to.have.property(
        "MyToken",
      );
      expect(output.contracts["fixtures/token.sol"].MyToken).to.have.property(
        "abi",
      );
      expect(output.contracts["fixtures/token.sol"].MyToken).to.have.property(
        "evm",
      );
      expect(
        output.contracts["fixtures/token.sol"].MyToken.evm,
      ).to.have.property("bytecode");
    });

    it("should successfully compile a valid Solidity contract that instantiates the token contracts", async function () {
      const standardInput = loadFixture("instantiate_tokens.json");

      const result = await compile(standardInput);
      expect(result).to.be.a("string");
      const output = JSON.parse(result);
      expect(output).to.have.property("contracts");
      expect(output.contracts["fixtures/instantiate_tokens.sol"]).to.have.property(
        "TokensFactory",
      );
      expect(output.contracts["fixtures/instantiate_tokens.sol"].TokensFactory).to.have.property(
        "abi",
      );
      expect(output.contracts["fixtures/instantiate_tokens.sol"].TokensFactory).to.have.property(
        "evm",
      );
      expect(
        output.contracts["fixtures/instantiate_tokens.sol"].TokensFactory.evm,
      ).to.have.property("bytecode");
    });
  }

  it("should throw an error for invalid Solidity code", async function () {
    const standardInput = loadFixture("invalid_contract_content.json");

    const result = await compile(standardInput);
    expect(result).to.be.a("string");
    const output = JSON.parse(result);
    expect(output).to.have.property("errors");
    expect(output.errors).to.be.an("array");
    expect(output.errors.length).to.be.greaterThan(0);
    expect(output.errors[0].type).to.exist;
    expect(output.errors[0].type).to.contain("ParserError");
  });

  it("should return not found error for missing imports", async function () {
    const standardInput = loadFixture("missing_import.json");

    const result = await compile(standardInput);
    const output = JSON.parse(result);
    expect(output).to.have.property("errors");
    expect(output.errors).to.be.an("array");
    expect(output.errors.length).to.be.greaterThan(0);
    expect(output.errors[0].message).to.exist;
    expect(output.errors[0].message).to.include(
      'Source "nonexistent/console.sol" not found',
    );
  });

  it("should successfully compile a valid Solidity contract that instantiates another contract", async function () {
    const standardInput = loadFixture("instantiate.json");

    const result = await compile(standardInput);
    expect(result).to.be.a("string");
    const output = JSON.parse(result);
    expect(output).to.have.property("contracts");
    expect(output.contracts["fixtures/instantiate.sol"]).to.have.property(
      "ChildContract",
    );
    expect(output.contracts["fixtures/instantiate.sol"].ChildContract).to.have.property(
      "abi",
    );
    expect(output.contracts["fixtures/instantiate.sol"].ChildContract).to.have.property(
      "evm",
    );
    expect(
      output.contracts["fixtures/instantiate.sol"].ChildContract.evm,
    ).to.have.property("bytecode");
    expect(output.contracts["fixtures/instantiate.sol"]).to.have.property(
      "MainContract",
    );
    expect(output.contracts["fixtures/instantiate.sol"].MainContract).to.have.property(
      "abi",
    );
    expect(output.contracts["fixtures/instantiate.sol"].MainContract).to.have.property(
      "evm",
    );
    expect(
      output.contracts["fixtures/instantiate.sol"].MainContract.evm,
    ).to.have.property("bytecode");
  });

});