@making-sense/antlr-editor/src/__tests__/advanced/error-scenarios.test.ts

ANTLR Typescript editor

import { describe, it, expect, vi } from "vitest";

// Test error handling scenarios without Monaco Editor
describe("Error Scenarios", () => {
    describe("Monaco Disposal Errors", () => {
        it("should handle InstantiationService disposal error", () => {
            const error = new Error("InstantiationService has been disposed");
            expect(error.message).toBe("InstantiationService has been disposed");
        });

        it("should detect disposal error in error message", () => {
            const error = new Error("InstantiationService has been disposed");
            const isDisposalError = error.message.includes("InstantiationService has been disposed");
            expect(isDisposalError).toBe(true);
        });

        it("should handle different disposal error formats", () => {
            const errors = [
                "InstantiationService has been disposed",
                "Monaco Editor InstantiationService has been disposed",
                "Error: InstantiationService has been disposed"
            ];

            errors.forEach(errorMessage => {
                const isDisposalError = errorMessage.includes("InstantiationService has been disposed");
                expect(isDisposalError).toBe(true);
            });
        });
    });

    describe("Error Event Handling", () => {
        it("should create error events", () => {
            const error = new Error("Test error");
            const errorEvent = new ErrorEvent("error", { error });

            expect(errorEvent.type).toBe("error");
            expect(errorEvent.error).toBe(error);
        });

        it("should handle preventDefault", () => {
            const error = new Error("Test error");
            const errorEvent = new ErrorEvent("error", { error });

            // Mock preventDefault
            const preventDefault = vi.fn();
            Object.defineProperty(errorEvent, "preventDefault", {
                value: preventDefault,
                writable: true
            });

            errorEvent.preventDefault();
            expect(preventDefault).toHaveBeenCalled();
        });
    });

    describe("Promise Rejection Handling", () => {
        it("should create promise rejection events", () => {
            const reason = { message: "Promise rejected" };

            // Mock PromiseRejectionEvent for testing without creating actual rejection
            const rejectionEvent = {
                type: "unhandledrejection",
                reason,
                promise: null
            };

            expect(rejectionEvent.type).toBe("unhandledrejection");
            expect(rejectionEvent.reason).toBe(reason);
        });

        it("should detect disposal errors in promise rejections", () => {
            const reason = { message: "InstantiationService has been disposed" };
            const isDisposalError = reason.message.includes("InstantiationService has been disposed");
            expect(isDisposalError).toBe(true);
        });
    });

    describe("Error Recovery", () => {
        it("should simulate error recovery process", () => {
            let hasError = false;
            let retryCount = 0;
            const maxRetries = 3;

            const simulateError = () => {
                hasError = true;
                retryCount++;
            };

            const attemptRecovery = () => {
                if (hasError && retryCount < maxRetries) {
                    hasError = false;
                    return true;
                }
                return false;
            };

            // Simulate error
            simulateError();
            expect(hasError).toBe(true);
            expect(retryCount).toBe(1);

            // Attempt recovery
            const recovered = attemptRecovery();
            expect(recovered).toBe(true);
            expect(hasError).toBe(false);
        });

        it("should handle multiple error scenarios", () => {
            const errorScenarios = [
                { message: "Network error", recoverable: true },
                { message: "InstantiationService has been disposed", recoverable: true },
                { message: "Fatal error", recoverable: false },
                { message: "Memory error", recoverable: false }
            ];

            errorScenarios.forEach(scenario => {
                const isDisposalError = scenario.message.includes(
                    "InstantiationService has been disposed"
                );
                const shouldRecover = scenario.recoverable || isDisposalError;

                if (isDisposalError) {
                    expect(shouldRecover).toBe(true);
                }
            });
        });
    });

    describe("Console Error Handling", () => {
        it("should mock console methods", () => {
            const originalWarn = console.warn;
            const mockWarn = vi.fn();
            console.warn = mockWarn;

            console.warn("Test warning");
            expect(mockWarn).toHaveBeenCalledWith("Test warning");

            // Restore
            console.warn = originalWarn;
        });

        it("should handle error logging", () => {
            const originalError = console.error;
            const mockError = vi.fn();
            console.error = mockError;

            console.error("Test error");
            expect(mockError).toHaveBeenCalledWith("Test error");

            // Restore
            console.error = originalError;
        });
    });

    describe("Global Error Handlers", () => {
        it("should simulate global error handler setup", () => {
            const errorHandler = vi.fn();
            const rejectionHandler = vi.fn();

            // Simulate adding event listeners
            const addEventListener = vi.fn();

            addEventListener("error", errorHandler, true);
            addEventListener("unhandledrejection", rejectionHandler);

            expect(addEventListener).toHaveBeenCalledWith("error", errorHandler, true);
            expect(addEventListener).toHaveBeenCalledWith("unhandledrejection", rejectionHandler);
        });

        it("should handle cleanup of event listeners", () => {
            const errorHandler = vi.fn();
            const removeEventListener = vi.fn();

            removeEventListener("error", errorHandler, true);
            removeEventListener("unhandledrejection", errorHandler);

            expect(removeEventListener).toHaveBeenCalledWith("error", errorHandler, true);
            expect(removeEventListener).toHaveBeenCalledWith("unhandledrejection", errorHandler);
        });
    });
});