opencouncil/src/app/api/admin/users/route.test.ts at ccfa416cf4c96e4b97e112fc75f129e6978b801d · schemalabz/opencouncil · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
/** @jest-environment node */

jest.mock('@/lib/auth', () => ({
  getCurrentUser: jest.fn(),
}));

jest.mock('@/lib/db/prisma', () => ({
  __esModule: true,
  default: {
    verificationToken: {
      create: jest.fn(),
      deleteMany: jest.fn(),
    },
  },
}));

jest.mock('@/lib/email/resend', () => ({
  sendEmail: jest.fn(),
}));

jest.mock('@react-email/render', () => ({
  renderAsync: jest.fn(),
}));

jest.mock('@/lib/email/templates/user-invite', () => ({
  UserInviteEmail: jest.fn(() => '<div>invite</div>'),
}));

jest.mock('@/env.mjs', () => ({
  env: {
    NEXTAUTH_URL: 'http://localhost:3000',
  },
}));

jest.mock('@/lib/db/users', () => ({
  createUser: jest.fn(),
  getUsers: jest.fn(),
  updateUser: jest.fn(),
}));

jest.mock('@/lib/discord', () => ({
  sendUserOnboardedAdminAlert: jest.fn(),
}));

import prisma from '@/lib/db/prisma';
import { getCurrentUser } from '@/lib/auth';
import { sendEmail } from '@/lib/email/resend';
import { renderAsync } from '@react-email/render';
import { createUser } from '@/lib/db/users';
import { sendUserOnboardedAdminAlert } from '@/lib/discord';
import { POST } from './route';

const mockGetCurrentUser = getCurrentUser as jest.MockedFunction<typeof getCurrentUser>;
const mockCreateUser = createUser as jest.MockedFunction<typeof createUser>;
const mockSendEmail = sendEmail as jest.MockedFunction<typeof sendEmail>;
const mockRenderAsync = renderAsync as jest.MockedFunction<typeof renderAsync>;
const mockVerificationTokenCreate = prisma.verificationToken.create as jest.MockedFunction<typeof prisma.verificationToken.create>;
const mockVerificationTokenDeleteMany = prisma.verificationToken.deleteMany as jest.MockedFunction<typeof prisma.verificationToken.deleteMany>;
const mockSendUserOnboardedAdminAlert = sendUserOnboardedAdminAlert as jest.MockedFunction<typeof sendUserOnboardedAdminAlert>;

describe('POST /api/admin/users', () => {
  beforeEach(() => {
    jest.clearAllMocks();
    mockGetCurrentUser.mockResolvedValue({ isSuperAdmin: true } as unknown as Awaited<ReturnType<typeof getCurrentUser>>);
    mockVerificationTokenCreate.mockResolvedValue({} as Awaited<ReturnType<typeof prisma.verificationToken.create>>);
    mockVerificationTokenDeleteMany.mockResolvedValue({ count: 1 });
    mockRenderAsync.mockResolvedValue('<html>invite</html>');
    mockSendEmail.mockResolvedValue({ success: true, message: 'Email sent successfully' });
    mockSendUserOnboardedAdminAlert.mockResolvedValue(undefined);
  });

  it('returns 401 when user is not super admin', async () => {
    mockGetCurrentUser.mockResolvedValueOnce(null);

    const request = new Request('http://localhost/api/admin/users', {
      method: 'POST',
      body: JSON.stringify({ email: 'test@example.com' }),
      headers: { 'Content-Type': 'application/json' },
    });

    const response = await POST(request);
    expect(response.status).toBe(401);
  });

  it('returns 409 and surfaces duplicate email message', async () => {
    mockCreateUser.mockRejectedValueOnce(new Error('A user with this email already exists.'));

    const request = new Request('http://localhost/api/admin/users', {
      method: 'POST',
      body: JSON.stringify({ email: 'duplicate@example.com', name: 'Duplicate User' }),
      headers: { 'Content-Type': 'application/json' },
    });

    const response = await POST(request);
    expect(response.status).toBe(409);
    await expect(response.json()).resolves.toEqual({
      error: 'A user with this email already exists.',
    });
  });

  it('returns success even when invite email sending fails', async () => {
    mockCreateUser.mockResolvedValueOnce({
      id: 'user-1',
      email: ' USER@Example.COM ',
      name: ' Test User ',
      administers: [],
    } as unknown as Awaited<ReturnType<typeof createUser>>);
    mockSendEmail.mockResolvedValueOnce({ success: false, message: 'Email failed' });

    const request = new Request('http://localhost/api/admin/users', {
      method: 'POST',
      body: JSON.stringify({
        email: ' USER@Example.COM ',
        name: ' Test User ',
        isSuperAdmin: false,
        administers: [],
      }),
      headers: { 'Content-Type': 'application/json' },
    });

    const response = await POST(request);

    expect(response.status).toBe(200);
    await expect(response.json()).resolves.toEqual(
      expect.objectContaining({
        id: 'user-1',
      })
    );
    expect(mockSendEmail).toHaveBeenCalledTimes(1);
    expect(mockVerificationTokenCreate).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({
          identifier: 'user@example.com',
        }),
      })
    );
    expect(mockVerificationTokenDeleteMany).toHaveBeenCalledWith(
      expect.objectContaining({
        where: expect.objectContaining({
          identifier: 'user@example.com',
          token: expect.any(String),
        }),
      })
    );
    expect(mockSendUserOnboardedAdminAlert).toHaveBeenCalledWith({
      cityName: 'Admin User',
      onboardingSource: 'admin_invite',
    });
  });
});