Implementing Cross-Package Tests with Jest in TypeScript

Cross-package testing is crucial for ensuring the stability and compatibility of interconnected TypeScript projects. This challenge focuses on setting up and executing Jest tests that span multiple packages within a monorepo, verifying interactions and dependencies between them. Successfully completing this challenge will allow you to confidently test the integration of your packages.

Problem Description

You are working with a monorepo containing two TypeScript packages: package-a and package-b. package-a exports a utility function formatString that package-b imports and uses. The goal is to create a Jest test suite within package-b that imports and tests the formatString function from package-a. This requires configuring Jest to resolve modules across package boundaries.

What needs to be achieved:

1. Structure a monorepo with package-a and package-b.
2. package-a should contain a simple utility function formatString.
3. package-b should import and use formatString from package-a.
4. Create a Jest test suite within package-b that tests formatString.
5. Configure Jest in package-b to correctly resolve the module path to package-a.

Key Requirements:

• The monorepo should be structured in a standard way (e.g., using lerna or yarn workspaces). For simplicity, assume a basic directory structure as described in the Examples.
• Jest should be configured to find and test modules across package boundaries.
• The tests should pass and demonstrate that formatString is correctly imported and functioning as expected.
• The solution should be written in TypeScript.

Expected Behavior:

When running Jest from within package-b, the tests should:

1. Successfully import formatString from package-a.
2. Execute the tests defined in package-b/src/tests/formatString.test.ts.
3. Assert that formatString returns the expected output for a given input.

Edge Cases to Consider:

• Incorrect module resolution paths in Jest configuration.
• Circular dependencies between packages (though this challenge doesn't require handling them, be aware of the potential).
• TypeScript compilation errors due to incorrect imports or types.

Examples

Example 1:

Monorepo Structure:

package-a/
  src/
    utils.ts
package-b/
  src/
    components/MyComponent.ts
  src/tests/
    formatString.test.ts
  jest.config.ts
package.json (root)
  workspaces:
    - package-a
    - package-b

Example 2:

package-a/src/utils.ts:

export function formatString(input: string): string {
  return `Formatted: ${input}`;
}

package-b/src/components/MyComponent.ts:

import { formatString } from 'package-a';

export function MyComponent() {
  return `Component using: ${formatString('Hello')}`;
}

package-b/src/tests/formatString.test.ts:

import { formatString } from 'package-a';

describe('formatString', () => {
  it('should format a string', () => {
    expect(formatString('test')).toBe('Formatted: test');
  });
});

package-b/jest.config.ts:

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  moduleNameMapper: {
    'package-a': ['<rootDir>/../package-a/src'],
  },
};

Example 3: (Edge Case - Incorrect Module Resolution)

If moduleNameMapper in package-b/jest.config.ts is incorrect (e.g., 'package-a': ['<rootDir>/package-a']), the tests will fail with a "Cannot find module 'package-a'" error. The correct path needs to point to the src directory within package-a.

Constraints

• The monorepo structure should be relatively simple (as described in the examples).
• You can use yarn workspaces or lerna for managing the monorepo. Assume they are already set up.
• The solution must be written in TypeScript.
• The tests should be executable using yarn test (or equivalent command based on your package manager) from the root of the monorepo.
• The solution should be self-contained and easily reproducible.

Notes

• Pay close attention to the module resolution paths in your Jest configuration. This is the most common source of errors when testing across packages.
• Consider using a monorepo tool like lerna or yarn workspaces to manage your packages and dependencies.
• The moduleNameMapper in Jest's configuration is key to telling Jest how to resolve modules from other packages. The path should be relative to the root of the monorepo.
• Ensure that your TypeScript configuration (tsconfig.json files in each package) are set up correctly to allow for module resolution.