Happner Test Modules

Common errors

• Error: Mesh not started

  cause Attempting to access `mesh.exchange` or `mesh.event` before the `happner` mesh has fully initialized or if `Happner.create` failed.
  fix Ensure that `await Happner.create(config)` has successfully completed before attempting any interactions with the mesh. Handle potential errors during mesh creation.

• TypeError: Cannot read property 'exchange' of undefined

  cause This usually indicates that the `mesh` object itself is undefined or null, meaning the `Happner.create` call likely failed or returned an unexpected value, or the `mesh` variable was not correctly assigned.
  fix Verify the `Happner.create(config)` call and its promise resolution. Debug the `mesh` variable to confirm it holds a valid `happner` instance after creation.

• SyntaxError: Unexpected token 'export' (or 'import')

  cause This error occurs when a CommonJS (CJS) environment tries to parse an ECMAScript Module (ESM) syntax (`import`/`export`). Given the age of `happner`, many projects are still CJS-based while modern libraries or test setups might use ESM.
  fix Check your `tsconfig.json` (for TypeScript) or Node.js `package.json`'s `type` field and `module` resolution settings. Ensure your test runner (e.g., Jest, Mocha) is configured to handle ESM, or transpile your code to CJS if the environment strictly requires it. For Node.js, ensure `.mjs` or `type: "module"` is used for ESM files, and `.cjs` or `type: "commonjs"` for CJS.

Warnings

• breaking Major version updates of `happner` itself may introduce breaking changes that require corresponding updates or adjustments in `happner-test-modules` usage or internal implementation. Always check `happner`'s migration guides for relevant changes.
  Fix: Consult the `happner` project's release notes and migration guides (e.g., from `happner-1` to `happner-2`) for specific changes. Update `happner-test-modules` to the latest compatible version.
• gotcha Tests involving `happner` meshes, especially those with multiple components or instances, can suffer from shared state issues if not properly isolated. This can lead to flaky tests that pass individually but fail when run in a suite.
  Fix: Ensure each test creates a fresh `happner` mesh instance and cleans it up (e.g., `mesh.stop()`) after completion. Avoid global state or ensure any shared resources are reset before each test run. Consider using a test runner's `beforeEach` and `afterEach` hooks.
• gotcha Improper shutdown of `happner` mesh instances in tests can lead to resource leaks (e.g., open ports, database connections) or interference with subsequent tests. This is particularly relevant in CI/CD environments.
  Fix: Always ensure `mesh.stop()` is called in an `afterEach` or `finally` block for every mesh created in a test, even if the test fails. This guarantees clean resource release.

Install

• npm install happner-test-modules npm
• yarn add happner-test-modules yarn
• pnpm add happner-test-modules pnpm

Imports

• createTestMesh
  wrong:

  const createTestMesh = require('happner-test-modules').createTestMesh;

  correct:

  import { createTestMesh } from 'happner-test-modules';

  While `happner` ecosystem often uses CommonJS, modern testing often prefers ESM imports. Both patterns might be seen depending on the project setup.
• TestComponent
  wrong:

  import TestComponent from 'happner-test-modules/lib/test-component';

  correct:

  import { TestComponent } from 'happner-test-modules';

  Assumes a named export for a common test component or helper. Direct path imports might bypass necessary module resolution if not careful.
• Happner
  wrong:

  const Happner = require('happner');

  correct:

  import * as Happner from 'happner';

  Although `happner-test-modules` is the subject, `happner` itself is often imported in test files. CommonJS `require` is typical for older `happner` projects, but ESM star import is used here for modern context.

Quickstart

This quickstart demonstrates how to create and interact with a basic `happner` mesh using `happner-test-modules` (implicitly through `happner.create`), define a simple component, call a method on it, and emit/receive an event.

import { createTestMesh } from 'happner-test-modules';
import Happner from 'happner'; // Assuming Happner is a default export for simplicity, or named import can be used

async function runHappnerTest() {
  const config = {
    name: 'testMesh',
    modules: {
      TestComponent: {
        instance: {
          testMethod: async (message) => {
            console.log(`TestComponent received: ${message}`);
            return `Processed: ${message}`;
          }
        }
      }
    },
    components: {
      TestComponent: {}
    }
  };

  let mesh;
  try {
    // Use happner-test-modules to create a test mesh
    mesh = await Happner.create(config);
    console.log('Happner test mesh started.');

    const result = await mesh.exchange.TestComponent.testMethod('Hello from test!');
    console.log(`Result from TestComponent: ${result}`);

    // Example of another test action
    const events = [];
    mesh.event.TestComponent.on('test-event', (data) => {
      events.push(data);
      console.log('Event received:', data);
    });
    await mesh.emit('TestComponent/test-event', { value: 'eventData' });

    // Wait a moment for events to propagate (in real tests, use promises/await for specific events)
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Events collected:', events);

  } catch (e) {
    console.error('Error during test:', e);
    process.exit(1);
  } finally {
    if (mesh) {
      await mesh.stop();
      console.log('Happner test mesh stopped.');
    }
  }
}

runHappnerTest();