chore: Move all of the unit tests that require a file to be served to a different workflow.

[nadr0]

We have unit tests that are not unit tests, for example

src/machines/modelingMachine.test.ts is not a unit test. You need a server up and running to run this unit test. We need a different test runner to run these types of tests. They are making our unit testing run time more difficult to use.

The following will not work

npx vitest run --mode development ./src/machines/modelingMachine.test.ts 

The following will work

npm run simpleserver:bg
# in another terminal
npx vitest run --mode development ./src/machines/modelingMachine.test.ts 

Our unit tests require a localhost server.

TODO: running list

• src/machines/modelingMachine.test.ts
• src/lang/modifyAst/addEdgeTreatment.test.ts

[nadr0]

Possible solution
b38b698#diff-babceb4f0e87174daa03d70f2624fbeabd92cdd61cbf6dbb0c6a2a2c6de7e69d

Using calls directly to the instance will have any types

We have src/lang/wasm.ts which has helper functions for instance.parse_wasm which will type everything. These are assuming a global runtime environment and the global wasm instance to be created. Port this into a wrapper class of RustContext seems wrong as well? It isn't really application code.

If I read this original unit test

  it('recasts a simple program', () => {
    const code = '1 + 2'
    const { ast } = code2ast(code)
    const recasted = recast(ast)
    if (err(recasted)) throw recasted
    expect(recasted.trim()).toBe(code)
  })

It is effectively doing

const code = '1 + 2'
const result = instance.parse_wasm(code)
const recasted = instance.recase_wasm(JSON.stringify(result[0]))
expect(recasted).toBe(code)

This code is not testing application code or business logic. It is wanted to test the functions within the WASM Blob. We have src/lang/wasm.ts to actually type it since the instance has no return types.

I would block the loading of the old pattern as well which would brick all tests which would require them to be updated.

// Initialise the wasm module.
const initialiseNode = async () => {
  if (processEnv()?.VITEST) {
    const message =
      'wasmUtilsNode is trying to call initialiseNode. This will be blocked in VITEST runtimes.'
    console.log(message)
    return Promise.resolve(message)
  }

[nadr0]

  it.only('calculates a simple expression without units', async () => {
    const instance = await loadAndInitialiseWasmInstance(WASM_PATH)
    const engineCommandManager = new ConnectionManager()
    const rustContext = new RustContext(engineCommandManager, instance)
    const actual = await getCalculatedKclExpressionValue('1 + 2', undefined, instance, rustContext)
    const coercedActual = actual as Exclude<typeof actual, Error | ParseResult>
    expect(coercedActual).not.toHaveProperty('errors')
    expect(coercedActual.valueAsString).toEqual('3')
    expect(coercedActual?.astNode).toBeDefined()
  })

Wow that is pretty nested to test this function. The amount of global singleton logic that is behind the scenes for this unit test is large.