Rafi Athallah
479 lines
18 KiB
JavaScript
479 lines
18 KiB
JavaScript
const axios = require('axios');
|
|
const bcrypt = require('bcrypt');
|
|
const { PrismaClient } = require('../src/generated/prisma');
|
|
|
|
const BASE_URL = 'http://localhost:9000';
|
|
const prisma = new PrismaClient();
|
|
|
|
function createMultipartPayload(boundary, fields, files) {
|
|
const chunks = [];
|
|
|
|
for (const [key, value] of Object.entries(fields)) {
|
|
if (value !== undefined && value !== null) {
|
|
chunks.push(Buffer.from(`--${boundary}\r\n` +
|
|
`Content-Disposition: form-data; name="${key}"\r\n\r\n` +
|
|
`${value}\r\n`));
|
|
}
|
|
}
|
|
|
|
for (const [key, file] of Object.entries(files)) {
|
|
if (file) {
|
|
chunks.push(Buffer.from(`--${boundary}\r\n` +
|
|
`Content-Disposition: form-data; name="${key}"; filename="${file.name}"\r\n` +
|
|
`Content-Type: ${file.type}\r\n\r\n`));
|
|
chunks.push(file.content);
|
|
chunks.push(Buffer.from('\r\n'));
|
|
}
|
|
}
|
|
|
|
chunks.push(Buffer.from(`--${boundary}--\r\n`));
|
|
return Buffer.concat(chunks);
|
|
}
|
|
|
|
async function runTests() {
|
|
console.log('=== STARTING INTEGRATION TESTS FOR CERTIFICATE TEMPLATE UPLOAD ===\n');
|
|
|
|
let adminToken = '';
|
|
let mentor1Token = '';
|
|
let mentor2Token = '';
|
|
let internToken = '';
|
|
let project1Id = null;
|
|
let project2Id = null;
|
|
|
|
const password = 'password123';
|
|
const internEmail = `new_intern_cert_${Date.now()}@internify.com`;
|
|
|
|
const getHeader = (token) => ({
|
|
headers: { Authorization: `Bearer ${token}` }
|
|
});
|
|
|
|
const getMultipartHeader = (token, boundary) => ({
|
|
headers: {
|
|
Authorization: `Bearer ${token}`,
|
|
'Content-Type': `multipart/form-data; boundary=${boundary}`
|
|
}
|
|
});
|
|
|
|
try {
|
|
// 1. Login as Admin
|
|
console.log('1. Logging in as Admin (admin1@internify.com)...');
|
|
const adminLoginRes = await axios.post(`${BASE_URL}/auth-api/login`, {
|
|
email: 'admin1@internify.com',
|
|
password: password
|
|
});
|
|
adminToken = adminLoginRes.data.data.token;
|
|
console.log(' Admin logged in successfully!\n');
|
|
|
|
// 2. Logging in as Mentors
|
|
console.log('2. Logging in as Mentors...');
|
|
const mentor1LoginRes = await axios.post(`${BASE_URL}/auth-api/login`, {
|
|
email: 'mentor1@internify.com',
|
|
password: password
|
|
});
|
|
mentor1Token = mentor1LoginRes.data.data.token;
|
|
|
|
const mentor2LoginRes = await axios.post(`${BASE_URL}/auth-api/login`, {
|
|
email: 'mentor2@internify.com',
|
|
password: password
|
|
});
|
|
mentor2Token = mentor2LoginRes.data.data.token;
|
|
console.log(' Mentors logged in successfully!\n');
|
|
|
|
// 3. Registering a new Intern to assign to Mentor 1 Project
|
|
console.log(`3. Registering a new Intern (${internEmail})...`);
|
|
|
|
// Create a new vacancy with an image upload to get a valid UUID id_lowongan_magang
|
|
const lwnBoundary = '----WebKitFormBoundaryLowonganUpload';
|
|
const lwnFields = {
|
|
posisi: 'Web Developer Test',
|
|
kelompok_peminatan: 'Software Engineering',
|
|
jobdesk: 'Testing task and certificate templates.',
|
|
lokasi: 'Remote',
|
|
kualifikasi: 'NodeJS',
|
|
benefit: 'Certificate',
|
|
durasi_awal: '2026-07-01',
|
|
durasi_akhir: '2026-10-01',
|
|
paid: 'unpaid'
|
|
};
|
|
const lwnFiles = {
|
|
image: { name: 'poster.png', type: 'image/png', content: Buffer.from('fake-image-data') }
|
|
};
|
|
const lwnPayload = createMultipartPayload(lwnBoundary, lwnFields, lwnFiles);
|
|
|
|
console.log(' Creating lowongan magang (vacancy) dynamically...');
|
|
const createLwnRes = await axios.post(
|
|
`${BASE_URL}/lowongan-magang-api/add`,
|
|
lwnPayload,
|
|
getMultipartHeader(adminToken, lwnBoundary)
|
|
);
|
|
const lowonganId = createLwnRes.data.data.id;
|
|
console.log(' Vacancy created successfully! ID:', lowonganId);
|
|
|
|
// Submit application (lamaran) using the add-mobile endpoint which also registers the student
|
|
console.log(' Submitting internship application (which registers the student profile)...');
|
|
const appBoundary = '----WebKitFormBoundaryApplicationSubmission';
|
|
const appFields = {
|
|
nama_depan: 'Intern',
|
|
nama_belakang: 'Cert',
|
|
email: internEmail,
|
|
kontak: '08123456789',
|
|
jurusan: 'Computer Science',
|
|
universitas: 'Intern University',
|
|
negara: 'Indonesia',
|
|
motivasi: 'I want to learn.',
|
|
relevant_skills: 'NodeJS, React'
|
|
};
|
|
const appFiles = {
|
|
cv: { name: 'cv.pdf', type: 'application/pdf', content: Buffer.from('fake-pdf-cv') },
|
|
portofolio: { name: 'portfolio.pdf', type: 'application/pdf', content: Buffer.from('fake-pdf-portfolio') }
|
|
};
|
|
const appPayload = createMultipartPayload(appBoundary, appFields, appFiles);
|
|
|
|
const applyRes = await axios.post(
|
|
`${BASE_URL}/lamaran-magang-api/add-mobile/${lowonganId}`,
|
|
appPayload,
|
|
{
|
|
headers: {
|
|
'Content-Type': `multipart/form-data; boundary=${appBoundary}`
|
|
}
|
|
}
|
|
);
|
|
const idMahasiswa = applyRes.data.data.id_mahasiswa;
|
|
console.log(' Application submitted successfully! Student ID:', idMahasiswa);
|
|
|
|
// Fetch all lamaran to get the lamaran ID
|
|
console.log(' Retrieving lamaran list to find the newly created lamaran ID...');
|
|
const listLamaranRes = await axios.get(`${BASE_URL}/lamaran-magang-api/get?limit=100`, getHeader(adminToken));
|
|
const lamaranList = listLamaranRes.data.data;
|
|
const lamaranItem = lamaranList.find(l => l.id_mahasiswa === idMahasiswa);
|
|
if (!lamaranItem) {
|
|
throw new Error('TEST FAILED: Created lamaran not found in lamaran list!');
|
|
}
|
|
const lamaranId = lamaranItem.id;
|
|
console.log(' Found Lamaran ID:', lamaranId);
|
|
|
|
// Accept application to create user account
|
|
console.log(' Accepting application to generate Intern user account...');
|
|
await axios.patch(`${BASE_URL}/lamaran-magang-api/update/${lamaranId}`, {
|
|
status: 'diterima'
|
|
}, getHeader(adminToken));
|
|
|
|
// Wait a brief moment for the user insertion to complete
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
|
|
// Force override user's password in the database directly
|
|
console.log(' Overriding intern user password in DB directly to password123...');
|
|
const hashedPassword = await bcrypt.hash('password123', 10);
|
|
await prisma.user.update({
|
|
where: { email: internEmail },
|
|
data: { password: hashedPassword }
|
|
});
|
|
|
|
// Login as new Intern
|
|
const internLoginRes = await axios.post(`${BASE_URL}/auth-api/login`, {
|
|
email: internEmail,
|
|
password: 'password123'
|
|
});
|
|
internToken = internLoginRes.data.data.token;
|
|
console.log(' Intern logged in successfully!\n');
|
|
|
|
// 4. Mentors create projects dynamically to establish ownership
|
|
console.log('4. Creating projects dynamically for Mentors...');
|
|
|
|
// Mentor 1 creates Project 1 and assigns Intern (newly registered)
|
|
const project1Res = await axios.post(`${BASE_URL}/project-api/add`, {
|
|
project_icon: 'code',
|
|
project_name: `Mentor 1 Project - ${Date.now()}`,
|
|
description: 'Owned by Mentor 1.',
|
|
start_date: '2026-07-01',
|
|
end_date: '2026-10-01',
|
|
member_emails: [internEmail]
|
|
}, getHeader(mentor1Token));
|
|
project1Id = project1Res.data.data.id;
|
|
|
|
// Mentor 2 creates Project 2
|
|
const project2Res = await axios.post(`${BASE_URL}/project-api/add`, {
|
|
project_icon: 'shield',
|
|
project_name: `Mentor 2 Project - ${Date.now()}`,
|
|
description: 'Owned by Mentor 2.',
|
|
start_date: '2026-07-01',
|
|
end_date: '2026-10-01',
|
|
member_emails: []
|
|
}, getHeader(mentor2Token));
|
|
project2Id = project2Res.data.data.id;
|
|
|
|
console.log(` Projects created: Project 1 ID = ${project1Id}, Project 2 ID = ${project2Id}\n`);
|
|
|
|
// Prepare dummy file contents for upload
|
|
const uploadBoundary = '----WebKitFormBoundaryTemplateUpload';
|
|
const dummyTemplateContent = Buffer.from('fake-png-template-content');
|
|
const uploadPayload = createMultipartPayload(uploadBoundary, {}, {
|
|
template: { name: 'cert_template.png', type: 'image/png', content: dummyTemplateContent }
|
|
});
|
|
|
|
// 5. Mentor 1 uploads template to Project 1 (Should succeed)
|
|
console.log(`5. Mentor 1 uploading certificate template to Project 1...`);
|
|
const uploadRes = await axios.post(
|
|
`${BASE_URL}/certificate-api/projects/${project1Id}/template`,
|
|
uploadPayload,
|
|
getMultipartHeader(mentor1Token, uploadBoundary)
|
|
);
|
|
console.log(' Response status:', uploadRes.status);
|
|
console.log(' Uploaded template path:', uploadRes.data.data.certificate_template);
|
|
if (!uploadRes.data.data.certificate_template.startsWith('/uploads/')) {
|
|
throw new Error('TEST FAILED: Uploaded template path does not start with /uploads/');
|
|
}
|
|
console.log(' PASSED: Mentor 1 successfully uploaded template to their own project.\n');
|
|
|
|
// 6. Mentor 2 tries to upload to Project 1 (Should fail - 403)
|
|
console.log(`6. Testing isolation: Mentor 2 trying to upload template to Project 1 (owned by Mentor 1)...`);
|
|
try {
|
|
await axios.post(
|
|
`${BASE_URL}/certificate-api/projects/${project1Id}/template`,
|
|
uploadPayload,
|
|
getMultipartHeader(mentor2Token, uploadBoundary)
|
|
);
|
|
throw new Error('TEST FAILED: Mentor 2 was able to upload template to Project 1!');
|
|
} catch (err) {
|
|
if (err.response && err.response.status === 403) {
|
|
console.log(' PASSED: Access denied with 403 Forbidden as expected.\n');
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
// 7. Admin uploads template to Project 1 (Should succeed)
|
|
console.log(`7. Admin uploading certificate template to Project 1...`);
|
|
const adminUploadRes = await axios.post(
|
|
`${BASE_URL}/certificate-api/projects/${project1Id}/template`,
|
|
uploadPayload,
|
|
getMultipartHeader(adminToken, uploadBoundary)
|
|
);
|
|
console.log(' Response status:', adminUploadRes.status);
|
|
console.log(' PASSED: Admin successfully uploaded template to project.\n');
|
|
|
|
// 8. Intern tries to upload template to Project 1 (Should fail - 401/403)
|
|
console.log(`8. Testing role restriction: Intern trying to upload template to Project 1...`);
|
|
try {
|
|
await axios.post(
|
|
`${BASE_URL}/certificate-api/projects/${project1Id}/template`,
|
|
uploadPayload,
|
|
getMultipartHeader(internToken, uploadBoundary)
|
|
);
|
|
throw new Error('TEST FAILED: Intern was able to upload template to Project 1!');
|
|
} catch (err) {
|
|
if (err.response && (err.response.status === 403 || err.response.status === 401)) {
|
|
console.log(` PASSED: Access denied with ${err.response.status} as expected.\n`);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
// 9. Intern retrieves project details and verifies certificate template path is returned
|
|
console.log(`9. Intern retrieving Project 1 details to verify certificate template exposure...`);
|
|
const projectDetailRes = await axios.get(`${BASE_URL}/project-api/get/${project1Id}`, getHeader(internToken));
|
|
console.log(' Project detail certificate_template:', projectDetailRes.data.data.certificate_template);
|
|
if (!projectDetailRes.data.data.certificate_template) {
|
|
throw new Error('TEST FAILED: Project detail response does not include certificate_template!');
|
|
}
|
|
console.log(' PASSED: Intern successfully retrieved project detail containing certificate template URL.\n');
|
|
|
|
// 10. Claim Certificate Tests
|
|
console.log('10. Claim Certificate Tests...');
|
|
|
|
// Get Intern User ID
|
|
const internUser = await prisma.user.findUnique({
|
|
where: { email: internEmail }
|
|
});
|
|
const internUserId = internUser.id;
|
|
console.log(` Intern User ID: ${internUserId}`);
|
|
|
|
// A. Claim before tasks are created (Should fail - 400)
|
|
console.log(' A. Trying to claim certificate before any tasks are created...');
|
|
try {
|
|
await axios.post(
|
|
`${BASE_URL}/certificate-api/claim`,
|
|
{ id_project: project1Id },
|
|
getHeader(internToken)
|
|
);
|
|
throw new Error('TEST FAILED: Intern claimed certificate with no tasks!');
|
|
} catch (err) {
|
|
if (err.response && err.response.status === 400) {
|
|
console.log(' PASSED: Claim failed with 400 Bad Request as expected.');
|
|
console.log(' Error Message:', err.response.data.message);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
// B. Create a task for Project 1
|
|
console.log(' B. Creating a task for Project 1...');
|
|
const task = await prisma.task.create({
|
|
data: {
|
|
id_project: project1Id,
|
|
slug: `final-assignment-${Date.now()}`,
|
|
title: 'Final Assignment',
|
|
description: 'Submit your final report.',
|
|
deadline_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days from now
|
|
submission_type: 'url_link'
|
|
}
|
|
});
|
|
console.log(` Task created successfully! ID: ${task.id}`);
|
|
|
|
// C. Claim before submitting tasks (Should fail - 400)
|
|
console.log(' C. Trying to claim certificate before task submission...');
|
|
try {
|
|
await axios.post(
|
|
`${BASE_URL}/certificate-api/claim`,
|
|
{ id_project: project1Id },
|
|
getHeader(internToken)
|
|
);
|
|
throw new Error('TEST FAILED: Intern claimed certificate without submitting tasks!');
|
|
} catch (err) {
|
|
if (err.response && err.response.status === 400) {
|
|
console.log(' PASSED: Claim failed with 400 Bad Request as expected.');
|
|
console.log(' Error Message:', err.response.data.message);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
// D. Submit the task
|
|
console.log(' D. Creating submission for the task...');
|
|
const submission = await prisma.taskSubmission.create({
|
|
data: {
|
|
id_task: task.id,
|
|
id_user: internUserId,
|
|
url_link: 'https://github.com/internify/report'
|
|
}
|
|
});
|
|
console.log(` Submission created successfully! ID: ${submission.id}`);
|
|
|
|
// E. Claim certificate (Should succeed - 201)
|
|
console.log(' E. Claiming certificate after submitting tasks...');
|
|
const claimRes = await axios.post(
|
|
`${BASE_URL}/certificate-api/claim`,
|
|
{ id_project: project1Id },
|
|
getHeader(internToken)
|
|
);
|
|
console.log(' Response status:', claimRes.status);
|
|
console.log(' Claimed Certificate No:', claimRes.data.data.certificate_no);
|
|
if (claimRes.status !== 201) {
|
|
throw new Error(`TEST FAILED: Expected status 201, got ${claimRes.status}`);
|
|
}
|
|
console.log(' PASSED: Certificate claimed successfully!\n');
|
|
|
|
// F. Claim certificate again (Should fail - 409)
|
|
console.log(' F. Trying to claim certificate again...');
|
|
try {
|
|
await axios.post(
|
|
`${BASE_URL}/certificate-api/claim`,
|
|
{ id_project: project1Id },
|
|
getHeader(internToken)
|
|
);
|
|
throw new Error('TEST FAILED: Intern claimed the same certificate twice!');
|
|
} catch (err) {
|
|
if (err.response && err.response.status === 409) {
|
|
console.log(' PASSED: Claim failed with 409 Conflict as expected.');
|
|
console.log(' Error Message:', err.response.data.message);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
// G. Retrieve my certificates (Should include the claimed certificate)
|
|
console.log(' G. Verifying certificate is in my certificates list...');
|
|
const myCertsRes = await axios.get(
|
|
`${BASE_URL}/certificate-api/my-certificates`,
|
|
getHeader(internToken)
|
|
);
|
|
console.log(' Certificates list length:', myCertsRes.data.data.length);
|
|
const foundCert = myCertsRes.data.data.find(c => c.id_project === project1Id);
|
|
if (!foundCert) {
|
|
throw new Error('TEST FAILED: Claimed certificate not found in my certificates list!');
|
|
}
|
|
console.log(' PASSED: Claimed certificate verified in list!\n');
|
|
|
|
// 11. Assign Member Restriction Tests
|
|
console.log('11. Assign Member Restriction Tests...');
|
|
|
|
// A. Assign Intern (who is active in Project 1) to Project 2 (Should fail - 409)
|
|
console.log(' A. Trying to assign intern (already active in Project 1) to Project 2...');
|
|
try {
|
|
await axios.post(
|
|
`${BASE_URL}/project-api/assign-member`,
|
|
{ id_project: project2Id, id_user: internUserId },
|
|
getHeader(mentor2Token)
|
|
);
|
|
throw new Error('TEST FAILED: Intern was assigned to two active projects!');
|
|
} catch (err) {
|
|
if (err.response && err.response.status === 409) {
|
|
console.log(' PASSED: Assign failed with 409 Conflict as expected.');
|
|
console.log(' Error Message:', err.response.data.message);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
// B. Remove intern from Project 1
|
|
console.log(' B. Removing intern from Project 1...');
|
|
const removeRes = await axios.post(
|
|
`${BASE_URL}/project-api/remove-member`,
|
|
{ id_project: project1Id, id_user: internUserId },
|
|
getHeader(mentor1Token)
|
|
);
|
|
console.log(' Response status:', removeRes.status);
|
|
if (removeRes.status !== 200) {
|
|
throw new Error(`TEST FAILED: Failed to remove member, got status ${removeRes.status}`);
|
|
}
|
|
console.log(' PASSED: Intern successfully removed from Project 1.');
|
|
|
|
// C. Assign intern to Project 2 (Should succeed now)
|
|
console.log(' C. Assigning intern to Project 2...');
|
|
const assignRes = await axios.post(
|
|
`${BASE_URL}/project-api/assign-member`,
|
|
{ id_project: project2Id, id_user: internUserId },
|
|
getHeader(mentor2Token)
|
|
);
|
|
console.log(' Response status:', assignRes.status);
|
|
if (assignRes.status !== 200) {
|
|
throw new Error(`TEST FAILED: Failed to assign member, got status ${assignRes.status}`);
|
|
}
|
|
console.log(' PASSED: Intern successfully assigned to Project 2.');
|
|
|
|
// D. Assign intern to Project 2 again (Should fail - 409)
|
|
console.log(' D. Trying to assign intern to Project 2 again...');
|
|
try {
|
|
await axios.post(
|
|
`${BASE_URL}/project-api/assign-member`,
|
|
{ id_project: project2Id, id_user: internUserId },
|
|
getHeader(mentor2Token)
|
|
);
|
|
throw new Error('TEST FAILED: Intern assigned to Project 2 twice!');
|
|
} catch (err) {
|
|
if (err.response && err.response.status === 409) {
|
|
console.log(' PASSED: Assign failed with 409 Conflict as expected.');
|
|
console.log(' Error Message:', err.response.data.message);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
console.log('=== ALL INTEGRATION TESTS PASSED SUCCESSFULLY! ===');
|
|
await prisma.$disconnect();
|
|
process.exit(0);
|
|
} catch (err) {
|
|
console.error('=== TEST EXECUTION ENCOUNTERED AN ERROR ===');
|
|
if (err.response) {
|
|
console.error(`Status: ${err.response.status}`);
|
|
console.error('Response Data:', JSON.stringify(err.response.data, null, 2));
|
|
} else {
|
|
console.error(err);
|
|
}
|
|
await prisma.$disconnect();
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
runTests();
|