/**
 * Tests for InitiateOidc handler
 *
 * Note: These are unit tests for handler logic.
 * For full integration tests, use the test-utils package in a demo app.
 */

import InitiateOidc from "../../src/handlers/InitiateOidc";
import { validateProvider } from "../../src/utils/error-utils";
import { generateState, generateSessionId, generateNonce } from "../../src/utils/state-utils";

describe("InitiateOidc handler", () => {
    describe("Route configuration", () => {
        it("should export correct route configuration", () => {
            const { Route } = require("../../src/handlers/InitiateOidc");
            expect(Route.path).toBe("/oidc/:provider/initiate");
            expect(Route.method).toBe("get");
        });
    });

    describe("Provider validation", () => {
        it("should validate provider name format", () => {
            expect(() => validateProvider("google")).not.toThrow();
            expect(() => validateProvider("microsoft")).not.toThrow();
            expect(() => validateProvider("custom-provider")).not.toThrow();
        });

        it("should reject invalid provider names", () => {
            expect(() => validateProvider("")).toThrow();
            expect(() => validateProvider("provider/slash")).toThrow();
            expect(() => validateProvider("provider with spaces")).toThrow();
        });
    });

    describe("Security parameter generation", () => {
        it("should generate unique state", () => {
            const state1 = generateState();
            const state2 = generateState();

            expect(state1).toBeDefined();
            expect(state2).toBeDefined();
            expect(state1).not.toBe(state2);
            expect(state1.length).toBe(64);
        });

        it("should generate unique session ID", () => {
            const id1 = generateSessionId();
            const id2 = generateSessionId();

            expect(id1).not.toBe(id2);
            expect(id1.length).toBe(32);
        });

        it("should generate unique nonce", () => {
            const nonce1 = generateNonce();
            const nonce2 = generateNonce();

            expect(nonce1).not.toBe(nonce2);
            expect(nonce1.length).toBe(32);
        });
    });
});