What is FizzBuzz Challenge?

npm install --save-dev jest ts-jest @types/jest

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  testMatch: ['**/*.spec.ts'],
};

import {
  ModuloRule,
  RuleEvaluatorPipeline,
  ConsoleOutputAdapter,
  EnterpriseFizzBuzzEngine,
  IFizzBuzzRule,
  IOutputHandler,
} from './fizzbuzz';

describe('Enterprise FizzBuzz System', () => {

  // 1. Unit Tests for ModuloRule Strategy
  describe('ModuloRule', () => {
    it('should throw an error if initialized with a zero or negative divisor', () => {
      expect(() => new ModuloRule(0, 'Fizz')).toThrow('Divisor must be a positive non-zero integer.');
      expect(() => new ModuloRule(-3, 'Fizz')).toThrow('Divisor must be a positive non-zero integer.');
    });

    it('should satisfy rule when value is evenly divisible', () => {
      const rule = new ModuloRule(3, 'Fizz');
      expect(rule.isSatisfiedBy(9)).toBe(true);
      expect(rule.getReplacement()).toBe('Fizz');
    });

    it('should not satisfy rule when value is not divisible', () => {
      const rule = new ModuloRule(3, 'Fizz');
      expect(rule.isSatisfiedBy(10)).toBe(false);
    });
  });

  // 2. Unit Tests for RuleEvaluatorPipeline (Chain of Responsibility)
  describe('RuleEvaluatorPipeline', () => {
    let pipeline: RuleEvaluatorPipeline;

    beforeEach(() => {
      const rules: IFizzBuzzRule[] = [
        new ModuloRule(3, 'Fizz'),
        new ModuloRule(5, 'Buzz'),
      ];
      pipeline = new RuleEvaluatorPipeline(rules);
    });

    it('should return string representation of number if no rules match', () => {
      expect(pipeline.evaluate(2)).toBe('2');
    });

    it('should return "Fizz" when divisible by 3 only', () => {
      expect(pipeline.evaluate(6)).toBe('Fizz');
    });

    it('should return "Buzz" when divisible by 5 only', () => {
      expect(pipeline.evaluate(10)).toBe('Buzz');
    });

    it('should concatenate tokens into "FizzBuzz" when matching multiple rules', () => {
      expect(pipeline.evaluate(15)).toBe('FizzBuzz');
    });
  });

  // 3. Unit Tests for EnterpriseFizzBuzzEngine (Service layer + Mocks)
  describe('EnterpriseFizzBuzzEngine', () => {
    let mockLogger: jest.Mocked<IOutputHandler>;
    let mockEvaluator: jest.Mocked<RuleEvaluatorPipeline>;
    let engine: EnterpriseFizzBuzzEngine;

    beforeEach(() => {
      mockLogger = { emit: jest.fn() };
      mockEvaluator = {
        evaluate: jest.fn((val: number) => `processed_${val}`),
      } as unknown as jest.Mocked<RuleEvaluatorPipeline>;

      engine = new EnterpriseFizzBuzzEngine(mockEvaluator, mockLogger);
    });

    it('should throw RangeError if start index exceeds end index', () => {
      expect(() => Array.from(engine.process(10, 5))).toThrow(RangeError);
    });

    it('should process range, invoke evaluator and emit logs for each number', () => {
      const results = Array.from(engine.process(1, 3));

      expect(results).toEqual(['processed_1', 'processed_2', 'processed_3']);
      expect(mockEvaluator.evaluate).toHaveBeenCalledTimes(3);
      expect(mockLogger.emit).toHaveBeenNthCalledWith(1, 'processed_1');
      expect(mockLogger.emit).toHaveBeenNthCalledWith(2, 'processed_2');
      expect(mockLogger.emit).toHaveBeenNthCalledWith(3, 'processed_3');
    });
  });

  // 4. Integration Test for Output Adapter
  describe('ConsoleOutputAdapter', () => {
    it('should call console.log with formatted message', () => {
      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
      const adapter = new ConsoleOutputAdapter();

      adapter.emit('Fizz');

      expect(consoleSpy).toHaveBeenCalledWith('[LOG] Fizz');
      consoleSpy.mockRestore();
    });
  });
});