Typescript Jest Tests seem to be receiving outdated/incorrect source data

I am unsure why there is a discrepency between the recieved function returns by Jest and test data that a script is recieving.

When I run this test:

test('inCheck pawn-wrong-direction-black', () => {
  const fen = '6/7/8/9/10/k4K5/10/9/8/7/6 w - 0 1'
  const chess = new HexChess(fen)
  chess.put('g5', { color: WHITE, type: PAWN })
  expect(chess.inCheck()).toEqual(false)
})

The test fails as the return value of chess.inCheck() is true.

When I run a ts-node script containing:

const fen = '6/7/8/9/10/k4K5/10/9/8/7/6 w - 0 1'
const chess = new HexChess(fen)
chess.put('g5', { color: WHITE, type: PAWN })
console.log(chess.inCheck())

The printed output is false.

The imports on both files are the same, so I do not see how there could be a difference of result. When debugging the test, it seems that the debugger also sees false unless the debugger breakpoint is within the actual test declaration.

It also seems like a test will occasionally change its status from failed to sucess, which confuses me as I am not sure what is changing. It should also be noted that the HexChess class does not depend on any random/third party data and all functions should be 1-1.

I have tried both npm run test and the Jest VSCode extension.

jest.config.js

/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
};

package.json

"scripts": {
    "test": "jest",

I am fairly new to both Jest and Typescript, so apologies if I am missing any important information.

In your HexClass you are importing methods from some file and assigning them as field vars to the class. Those methods go on to use this, but that this is actually referencing the function and not the class.

The individual methods now have their own scope, but also that scope will be shared every time you import those files elsewhere as node modules act a little bit like singletons (actually, not strictly speaking, but it works to make sense of this here).

You need to define the methods in the class and not initialise them in field vars from modules. That way they will reference the class scope, and not break class encapsulation.

If you really want to split it up then just do:

example.js

const example = (args // pass in scope from class) => ... body

export default example

Class

import example from './methods/example'

class YourClass {

   example() {
      example(this.stuff) // pass in relevant scope
   }
}

In addition, you are setting field vars to constants initialised outside the class scope like _board to EMPTY_BOARD, probably on the assumption those constants will be copied. However, what actually happens is that all class instances will be referencing and mutating the same EMPTY_BOARD "constant". That means each class instance is not encapsulated and there is bleed between them.

Here is a playground that demonstrates this issue and a playground that shows how it can be fixed by ensuring a new object is initialised each time.