/**
* Test suite for Auth module
*/
import { describe, it, expect, beforeAll } from '@jest/globals';
import {
login,
logout,
refreshToken,
validateSession,
authTools,
} from '../src/modules/auth.js';
import type {
LoginRequest,
RefreshTokenRequest,
} from '../src/types/auth.js';
/**
* Note: These tests require a running Komodo instance and valid credentials
* Set environment variables before running:
* - KOMODO_URL
* - KOMODO_API_KEY
* - KOMODO_API_SECRET
*/
describe('Auth Module', () => {
describe('login', () => {
it('should reject empty username', async () => {
const credentials: LoginRequest = {
username: '',
password: 'test-password',
};
await expect(login(credentials)).rejects.toThrow('Username is required');
});
it('should reject empty password', async () => {
const credentials: LoginRequest = {
username: 'test-user',
password: '',
};
await expect(login(credentials)).rejects.toThrow('Password is required');
});
it('should reject whitespace-only username', async () => {
const credentials: LoginRequest = {
username: ' ',
password: 'test-password',
};
await expect(login(credentials)).rejects.toThrow('Username is required');
});
it('should reject whitespace-only password', async () => {
const credentials: LoginRequest = {
username: 'test-user',
password: ' ',
};
await expect(login(credentials)).rejects.toThrow('Password is required');
});
// Integration test - requires valid Komodo instance
it.skip('should successfully login with valid credentials', async () => {
const credentials: LoginRequest = {
username: process.env.TEST_USERNAME || 'admin',
password: process.env.TEST_PASSWORD || 'password',
remember: false,
};
const result = await login(credentials);
expect(result).toHaveProperty('success');
expect(result.success).toBe(true);
expect(result).toHaveProperty('token');
expect(result).toHaveProperty('session');
expect(result).toHaveProperty('user');
});
});
describe('logout', () => {
// Integration test - requires active session
it.skip('should successfully logout', async () => {
const result = await logout();
expect(result).toHaveProperty('success');
expect(result).toHaveProperty('message');
expect(result.success).toBe(true);
});
});
describe('refreshToken', () => {
it('should reject empty refresh token', async () => {
const request: RefreshTokenRequest = {
refreshToken: '',
};
await expect(refreshToken(request)).rejects.toThrow('Refresh token is required');
});
it('should reject whitespace-only refresh token', async () => {
const request: RefreshTokenRequest = {
refreshToken: ' ',
};
await expect(refreshToken(request)).rejects.toThrow('Refresh token is required');
});
// Integration test - requires valid refresh token
it.skip('should successfully refresh token', async () => {
const request: RefreshTokenRequest = {
refreshToken: process.env.TEST_REFRESH_TOKEN || 'test-token',
};
const result = await refreshToken(request);
expect(result).toHaveProperty('success');
expect(result).toHaveProperty('accessToken');
expect(result).toHaveProperty('expiresIn');
});
});
describe('validateSession', () => {
// Integration test - requires active session
it.skip('should validate active session', async () => {
const result = await validateSession();
expect(result).toHaveProperty('valid');
expect(result.valid).toBe(true);
expect(result).toHaveProperty('sessionId');
expect(result).toHaveProperty('userId');
expect(result).toHaveProperty('expiresAt');
});
});
describe('MCP Tool Definitions', () => {
it('should export komodo_auth_Login tool', () => {
expect(authTools.komodo_auth_Login).toBeDefined();
expect(authTools.komodo_auth_Login.name).toBe('komodo_auth_Login');
expect(authTools.komodo_auth_Login.description).toBeTruthy();
expect(authTools.komodo_auth_Login.inputSchema).toBeDefined();
expect(authTools.komodo_auth_Login.handler).toBeInstanceOf(Function);
});
it('should export komodo_auth_Logout tool', () => {
expect(authTools.komodo_auth_Logout).toBeDefined();
expect(authTools.komodo_auth_Logout.name).toBe('komodo_auth_Logout');
expect(authTools.komodo_auth_Logout.description).toBeTruthy();
expect(authTools.komodo_auth_Logout.inputSchema).toBeDefined();
expect(authTools.komodo_auth_Logout.handler).toBeInstanceOf(Function);
});
it('should export komodo_auth_RefreshToken tool', () => {
expect(authTools.komodo_auth_RefreshToken).toBeDefined();
expect(authTools.komodo_auth_RefreshToken.name).toBe('komodo_auth_RefreshToken');
expect(authTools.komodo_auth_RefreshToken.description).toBeTruthy();
expect(authTools.komodo_auth_RefreshToken.inputSchema).toBeDefined();
expect(authTools.komodo_auth_RefreshToken.handler).toBeInstanceOf(Function);
});
it('should export komodo_auth_ValidateSession tool', () => {
expect(authTools.komodo_auth_ValidateSession).toBeDefined();
expect(authTools.komodo_auth_ValidateSession.name).toBe('komodo_auth_ValidateSession');
expect(authTools.komodo_auth_ValidateSession.description).toBeTruthy();
expect(authTools.komodo_auth_ValidateSession.inputSchema).toBeDefined();
expect(authTools.komodo_auth_ValidateSession.handler).toBeInstanceOf(Function);
});
it('should have correct input schema for login', () => {
const schema = authTools.komodo_auth_Login.inputSchema;
expect(schema.type).toBe('object');
expect(schema.properties).toHaveProperty('username');
expect(schema.properties).toHaveProperty('password');
expect(schema.properties).toHaveProperty('remember');
expect(schema.required).toContain('username');
expect(schema.required).toContain('password');
});
it('should have correct input schema for refreshToken', () => {
const schema = authTools.komodo_auth_RefreshToken.inputSchema;
expect(schema.type).toBe('object');
expect(schema.properties).toHaveProperty('refreshToken');
expect(schema.required).toContain('refreshToken');
});
it('should have empty input schema for logout and validateSession', () => {
expect(authTools.komodo_auth_Logout.inputSchema.properties).toEqual({});
expect(authTools.komodo_auth_ValidateSession.inputSchema.properties).toEqual({});
});
});
describe('MCP Tool Handlers', () => {
it('should handle login errors gracefully', async () => {
const result = await authTools.komodo_auth_Login.handler({
username: '',
password: 'test',
});
expect(result).toHaveProperty('content');
expect(result).toHaveProperty('isError');
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Error');
});
it('should handle refreshToken errors gracefully', async () => {
const result = await authTools.komodo_auth_RefreshToken.handler({
refreshToken: '',
});
expect(result).toHaveProperty('content');
expect(result).toHaveProperty('isError');
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Error');
});
});
});
