Files
canina/backend/src/auth/public-author.spec.ts
T
Canina Automation 69dd6922f6
Stage author bootstrap (dedicated repair) / bootstrap (push) Successful in 1m5s
Deploy Canina / deploy (push) Successful in 2m41s
fix(stage): accept persisted ADMIN human role in maintenance
2026-10-28 21:08:40 +00:00

134 lines
8.8 KiB
TypeScript

import { UnauthorizedException, ForbiddenException } from '@nestjs/common';
import { validate } from 'class-validator';
import * as bcrypt from 'bcryptjs';
import { readFileSync } from 'fs';
import { join } from 'path';
import { AuthService } from './auth.service';
import { JwtStrategy } from './jwt.strategy';
import { JwtAuthGuard } from './jwt-auth.guard';
import { RolesGuard } from '../common/guards/roles.guard';
import { HumanAdminGuard } from '../common/guards/human-admin.guard';
import { assertPrincipalActive } from './stage-test-principal';
import { RegisterDto } from './dto/register.dto';
import { LoginDto } from './dto/login.dto';
describe('Public authors are attribution only, never principals', () => {
const password = 'test-password';
const author = { id: 'author-id', mobile: '09123456789', email: 'author@example.invalid', password: bcrypt.hashSync(password, 4), role: 'SUPER_ADMIN', isPublicAuthor: true };
let prisma: any, jwt: any, redis: any, sms: any, service: AuthService;
const env = { ...process.env };
beforeEach(() => {
process.env.JWT_SECRET = 'isolated-public-author-test-secret';
process.env.JWT_REFRESH_SECRET = 'isolated-public-author-refresh-secret';
prisma = { user: { findUnique: jest.fn().mockResolvedValue(author), findFirst: jest.fn().mockResolvedValue(author), create: jest.fn() } };
jwt = { sign: jest.fn().mockReturnValue('token'), verify: jest.fn().mockReturnValue({ sub: author.id, jti: 'old-token' }) };
redis = { get: jest.fn(async (key: string) => key.startsWith('otp_attempts:') ? null : key === `otp:${author.mobile}` ? '12345' : key.startsWith('refresh_token:') ? '1' : null), set: jest.fn(), del: jest.fn(), incr: jest.fn().mockResolvedValue(1) };
sms = { sendOtp: jest.fn().mockResolvedValue(true) };
service = new AuthService(prisma, jwt, redis, sms);
});
afterEach(() => { process.env = { ...env }; });
it('shared principal assertion rejects the marker independent of role/mobile', () => {
expect(() => assertPrincipalActive(author)).toThrow(UnauthorizedException);
const withoutMobile = { ...author, mobile: null };
expect(() => assertPrincipalActive(withoutMobile)).toThrow(UnauthorizedException);
});
it.each(['User_PetOwner', 'Admin', 'ADMIN', 'SUPER_ADMIN'])('blocks password login even with role %s', async role => {
prisma.user.findUnique.mockResolvedValue({ ...author, role });
await expect(service.login({ mobile: author.mobile, password })).rejects.toThrow(UnauthorizedException);
expect(jwt.sign).not.toHaveBeenCalled();
});
it('does not send or store an OTP for a public author', async () => {
await expect(service.sendOtp({ phoneNumber: author.mobile })).rejects.toThrow(UnauthorizedException);
expect(sms.sendOtp).not.toHaveBeenCalled();
expect(redis.set).not.toHaveBeenCalled();
});
it('blocks a previously issued valid OTP without creating an alternate account', async () => {
await expect(service.verifyOtp({ phoneNumber: author.mobile, code: '12345' })).rejects.toThrow(UnauthorizedException);
expect(prisma.user.create).not.toHaveBeenCalled();
expect(jwt.sign).not.toHaveBeenCalled();
});
it.each(['Admin', 'ADMIN', 'SUPER_ADMIN'])('blocks email/admin login including nonproduction fallback for %s', async role => {
process.env.NODE_ENV = 'test';
process.env.ADMIN_EMAIL = author.email;
process.env.ADMIN_PASSWORD = password;
prisma.user.findFirst.mockResolvedValue({ ...author, role, password: null });
await expect(service.adminLogin({ email: author.email, password })).rejects.toThrow(UnauthorizedException);
expect(jwt.sign).not.toHaveBeenCalled();
});
it('blocks email/admin login with a valid stored password', async () => {
await expect(service.adminLogin({ email: author.email, password })).rejects.toThrow(UnauthorizedException);
expect(jwt.sign).not.toHaveBeenCalled();
});
it('email lookup cannot hide a public author behind a non-admin role and enter fallback', async () => {
process.env.ADMIN_EMAIL = author.email;
process.env.ADMIN_PASSWORD = password;
prisma.user.findFirst.mockResolvedValue({ ...author, role: 'User_PetOwner' });
await expect(service.adminLogin({ email: author.email, password })).rejects.toThrow(UnauthorizedException);
expect(prisma.user.findFirst).toHaveBeenCalledWith({ where: { email: author.email } });
expect(jwt.sign).not.toHaveBeenCalled();
});
it('blocks refresh-token rotation for an existing author account', async () => {
await expect(service.refreshToken('previous-token')).rejects.toThrow(UnauthorizedException);
expect(jwt.sign).not.toHaveBeenCalled();
});
it('blocks legacy refresh even when supplied principal omits the marker', async () => {
await expect(service.refresh({ id: author.id, role: 'SUPER_ADMIN' })).rejects.toThrow(UnauthorizedException);
expect(jwt.sign).not.toHaveBeenCalled();
});
it.each(['Bearer old-token', 'cookie'])('rejects existing JWT via %s using database marker, not token claims', async transport => {
const strategy = new JwtStrategy({ findById: jest.fn().mockResolvedValue(author) } as any, redis);
const headers = transport === 'cookie' ? { cookie: 'accessToken=old-token' } : { authorization: transport };
await expect(strategy.validate({ headers } as any, { sub: author.id, role: 'SUPER_ADMIN' })).rejects.toThrow(UnauthorizedException);
});
it('JWT guard rejects an accidentally supplied author principal', () => {
expect(() => new JwtAuthGuard().handleRequest(null, author)).toThrow(UnauthorizedException);
});
it('API-key guard rejects an accidentally marked principal', async () => {
const guard = new JwtAuthGuard({ validateKey: jest.fn().mockResolvedValue({ ...author, isApiKey: true, scopes: ['admin'] }) } as any);
const request = { headers: { 'x-api-key': 'test-key' } };
await expect(guard.canActivate({ switchToHttp: () => ({ getRequest: () => request }) } as any)).rejects.toThrow(UnauthorizedException);
});
it.each([{ roles: ['Admin'] }, { roles: [] }])('role guard rejects author even for roles %j', ({ roles }) => {
const guard = new RolesGuard({ getAllAndOverride: () => roles } as any);
const ctx = { getHandler: () => null, getClass: () => null, switchToHttp: () => ({ getRequest: () => ({ user: author }) }) } as any;
expect(() => guard.canActivate(ctx)).toThrow(ForbiddenException);
});
it.each(['Admin', 'ADMIN', 'SUPER_ADMIN'])('human admin guard accepts actual human role %s', role => {
const ctx = { switchToHttp: () => ({ getRequest: () => ({ user: { role } }) }) } as any;
expect(new HumanAdminGuard().canActivate(ctx)).toBe(true);
});
it.each(['User_PetOwner', 'adminsuper', '', undefined])('human admin guard denies nonallowlisted role %s', role => {
const ctx = { switchToHttp: () => ({ getRequest: () => ({ user: { role } }) }) } as any;
expect(() => new HumanAdminGuard().canActivate(ctx)).toThrow(ForbiddenException);
});
it('human admin guard rejects author with admin role', () => {
const ctx = { switchToHttp: () => ({ getRequest: () => ({ user: author }) }) } as any;
expect(() => new HumanAdminGuard().canActivate(ctx)).toThrow(ForbiddenException);
});
it.each([undefined, null, '', ' '])('registration still requires mobile %j before any database write', async mobile => {
prisma.user.findUnique.mockResolvedValue(null);
prisma.user.create.mockResolvedValue({ ...author, mobile, isPublicAuthor: false });
await expect(service.register({ firstName: 'Real', lastName: 'User', mobile } as any)).rejects.toThrow();
expect(prisma.user.create).not.toHaveBeenCalled();
});
it.each([RegisterDto, LoginDto])('real-user DTO retains required mobile validation', async Dto => {
const dto = Object.assign(new Dto(), { firstName: 'Real', lastName: 'User', password });
expect((await validate(dto)).some(error => error.property === 'mobile')).toBe(true);
});
it('real users can still login, verify OTP and refresh', async () => {
const real = { ...author, isPublicAuthor: false };
prisma.user.findUnique.mockResolvedValue(real);
await expect(service.login({ mobile: real.mobile, password })).resolves.toMatchObject({ success: true });
await expect(service.verifyOtp({ phoneNumber: real.mobile, code: '12345' })).resolves.toMatchObject({ success: true });
await expect(service.refreshToken('previous-token')).resolves.toMatchObject({ success: true });
await expect(service.refresh({ id: real.id })).resolves.toMatchObject({ success: true });
});
it('Prisma author storage permits absent mobile and defaults marker false', () => {
const schema = readFileSync(join(__dirname, '../../prisma/schema.prisma'), 'utf8');
const user = schema.match(/model User \{([\s\S]*?)\n\}/)![1];
expect(user).toMatch(/mobile\s+String\?\s+@unique/);
expect(user).toMatch(/isPublicAuthor\s+Boolean\s+@default\(false\)\s+@map\("is_public_author"\)/);
});
});