mirror of
https://github.com/ets-cfuhrman-pfe/EvalueTonSavoir.git
synced 2025-08-11 21:23:54 -04:00
492 lines
20 KiB
JavaScript
492 lines
20 KiB
JavaScript
const Folder = require('../models/folders');
|
|
const Quiz = require('../models/quizzes');
|
|
const db = require('../config/db');
|
|
|
|
console.log('db:', db); // Debugging line
|
|
console.log('db.getConnection:', db.getConnection); // Debugging line
|
|
|
|
describe('Folders', () => {
|
|
const quiz = new Quiz(db);
|
|
const folder = new Folder(db, quiz);
|
|
let database;
|
|
|
|
beforeAll(async () => {
|
|
console.log('beforeAll: db.getConnection:', db.getConnection); // Debugging line
|
|
database = await db.getConnection();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await db.closeConnection();
|
|
});
|
|
|
|
// it('should insert a folder into collection', async () => {
|
|
// const folders = new Folder(db, Quiz);
|
|
// const folderId = await folders.create('Test Folder', '12345');
|
|
// const result = await database.collection('folders').findOne({ _id: folderId });
|
|
// expect(result).toBeTruthy();
|
|
// console.log('found folder result:', result); // Debugging line
|
|
// expect(result.title).toBe('Test Folder');
|
|
// });
|
|
|
|
describe('create', () => {
|
|
it('should create a new folder and return the new folder ID', async () => {
|
|
const title = 'Test Folder';
|
|
const userId = '12345';
|
|
|
|
// Ensure the folder does not exist before the test
|
|
await database.collection('folders').deleteMany({ title, userId });
|
|
|
|
const result = await folder.create(title, userId);
|
|
|
|
const createdFolder = await database.collection('folders').findOne({ _id: result });
|
|
|
|
expect(createdFolder).toBeTruthy();
|
|
expect(createdFolder.title).toBe(title);
|
|
expect(createdFolder.userId).toBe(userId);
|
|
});
|
|
|
|
it('should throw an error if userId is undefined', async () => {
|
|
const title = 'Test Folder';
|
|
|
|
await expect(folder.create(title, undefined)).rejects.toThrow('Missing required parameter(s)');
|
|
});
|
|
|
|
it('should throw an error if the folder already exists', async () => {
|
|
const title = 'Existing Folder';
|
|
const userId = '12345';
|
|
|
|
// Ensure the folder exists before the test
|
|
await database.collection('folders').insertOne({ title, userId, created_at: new Date() });
|
|
|
|
await expect(folder.create(title, userId)).rejects.toThrow('Folder already exists');
|
|
|
|
// Clean up
|
|
await database.collection('folders').deleteMany({ title, userId });
|
|
});
|
|
});
|
|
|
|
|
|
// getUserFolders
|
|
describe('getUserFolders', () => {
|
|
it('should return all folders for a user', async () => {
|
|
const userId = '12345';
|
|
const userFolders = [
|
|
{ title: 'Folder 1', userId },
|
|
{ title: 'Folder 2', userId },
|
|
];
|
|
// Ensure the folders do not exist before the test
|
|
await database.collection('folders').deleteMany({ userId });
|
|
|
|
// Insert the folders
|
|
await database.collection('folders').insertMany(userFolders);
|
|
|
|
const result = await folder.getUserFolders(userId);
|
|
|
|
expect(result).toEqual(userFolders);
|
|
|
|
// Clean up
|
|
await database.collection('folders').deleteMany({ userId });
|
|
|
|
});
|
|
});
|
|
|
|
// getOwner
|
|
describe('getOwner', () => {
|
|
it('should return the owner of a folder', async () => {
|
|
// userId must be 24-char hex string
|
|
const userId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
|
|
expect(userId.length).toBe(24);
|
|
expect(/^[0-9A-Fa-f]{24}$/.test(userId)).toBe(true);
|
|
|
|
// create the folder using the folder API
|
|
const folderId = await folder.create('Test Folder', userId);
|
|
|
|
const folderIdString = folderId.toString();
|
|
|
|
expect(folderIdString.length).toBe(24);
|
|
expect(/^[0-9A-Fa-f]{24}$/.test(folderIdString)).toBe(true);
|
|
|
|
const result = await folder.getOwner(folderIdString);
|
|
|
|
expect(result).toBe(userId);
|
|
});
|
|
});
|
|
|
|
// write a test for getContent
|
|
describe('getContent', () => {
|
|
it('should return the content of a folder', async () => {
|
|
|
|
// create a new folder
|
|
const folderId = await folder.create('Test Folder', '12345');
|
|
|
|
// Insert the content using the quiz API
|
|
const _quiz1ObjectId = await quiz.create('Quiz 1', [], folderId.toString(), '12345');
|
|
const _quiz2ObjectId = await quiz.create('Quiz 2', [], folderId.toString(), '12345');
|
|
|
|
const content = [
|
|
{ title: 'Quiz 1', content: [], _id: _quiz1ObjectId, created_at: expect.any(Date), updated_at: expect.any(Date), folderId: folderId.toString(), userId: '12345' },
|
|
{ title: 'Quiz 2', content: [], _id: _quiz2ObjectId, created_at: expect.any(Date), updated_at: expect.any(Date), folderId: folderId.toString(), userId: '12345' },
|
|
];
|
|
|
|
const result = await folder.getContent(folderId.toString());
|
|
|
|
expect(result).toEqual(content);
|
|
|
|
// Clean up
|
|
await database.collection('files').deleteMany({ folderId: folderId.toString() });
|
|
await database.collection('folders').deleteMany({ _id: folderId });
|
|
});
|
|
|
|
it('should return an empty array if the folder has no content', async () => {
|
|
// create a new folder
|
|
const folderId = await folder.create('Test Folder', '12345');
|
|
|
|
const content = [];
|
|
const result = await folder.getContent(folderId.toString());
|
|
|
|
expect(result).toEqual(content);
|
|
|
|
// Clean up
|
|
await database.collection('folders').deleteMany({ _id: folderId });
|
|
});
|
|
});
|
|
|
|
|
|
|
|
// // write a test for getContent
|
|
// describe('getContent', () => {
|
|
// it('should return the content of a folder', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const content = [
|
|
// { title: 'Quiz 1', content: [] },
|
|
// { title: 'Quiz 2', content: [] },
|
|
// ];
|
|
|
|
// // Mock the database response
|
|
// collection.find().toArray.mockResolvedValue(content);
|
|
|
|
// const result = await folders.getContent(folderId);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('files');
|
|
// expect(collection.find).toHaveBeenCalledWith({ folderId });
|
|
// expect(result).toEqual(content);
|
|
// });
|
|
|
|
// it('should return an empty array if the folder has no content', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
|
|
// // Mock the database response
|
|
// collection.find().toArray.mockResolvedValue([]);
|
|
|
|
// const result = await folders.getContent(folderId);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('files');
|
|
// expect(collection.find).toHaveBeenCalledWith({ folderId });
|
|
// expect(result).toEqual([]);
|
|
// });
|
|
// });
|
|
|
|
// // delete
|
|
// describe('delete', () => {
|
|
// it('should delete a folder and return true', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
|
|
// // Mock the database response
|
|
// collection.deleteOne.mockResolvedValue({ deletedCount: 1 });
|
|
|
|
|
|
// // Mock the folders.quizModel.deleteQuizzesByFolderId()
|
|
// jest.spyOn(quizzes, 'deleteQuizzesByFolderId').mockResolvedValue(true);
|
|
|
|
// const result = await folders.delete(folderId);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.deleteOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// expect(result).toBe(true);
|
|
// });
|
|
|
|
// it('should return false if the folder does not exist', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
|
|
// // Mock the database response
|
|
// collection.deleteOne.mockResolvedValue({ deletedCount: 0 });
|
|
|
|
// const result = await folders.delete(folderId);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.deleteOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// expect(result).toBe(false);
|
|
// });
|
|
// });
|
|
|
|
// // rename
|
|
// describe('rename', () => {
|
|
// it('should rename a folder and return true', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const newTitle = 'New Folder Name';
|
|
// const userId = '12345';
|
|
|
|
// // Mock the database response
|
|
// collection.updateOne.mockResolvedValue({ modifiedCount: 1 });
|
|
|
|
// const result = await folders.rename(folderId, userId, newTitle);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// // { _id: ObjectId.createFromHexString(folderId), userId: userId }, { $set: { title: newTitle } }
|
|
// expect(collection.updateOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId), userId: userId }, { $set: { title: newTitle } });
|
|
// expect(result).toBe(true);
|
|
// });
|
|
|
|
// it('should return false if the folder does not exist', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const newTitle = 'New Folder Name';
|
|
// const userId = '12345';
|
|
|
|
// // Mock the database response
|
|
// collection.updateOne.mockResolvedValue({ modifiedCount: 0 });
|
|
|
|
// const result = await folders.rename(folderId, userId, newTitle);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.updateOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId), userId: userId }, { $set: { title: newTitle } });
|
|
// expect(result).toBe(false);
|
|
// });
|
|
|
|
// it('should throw an error if the new title is already in use', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const newTitle = 'Existing Folder';
|
|
// const userId = '12345';
|
|
|
|
// // Mock the database response
|
|
// collection.findOne.mockResolvedValue({ title: newTitle });
|
|
// collection.updateOne.mockResolvedValue({ modifiedCount: 0 });
|
|
|
|
// await expect(folders.rename(folderId, userId, newTitle)).rejects.toThrow(`Folder with name '${newTitle}' already exists.`);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// // expect(collection.updateOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) }, { $set: { title: newTitle } });
|
|
// expect(collection.findOne).toHaveBeenCalledWith({ userId: userId, title: newTitle });
|
|
// });
|
|
// });
|
|
|
|
// // duplicate
|
|
// describe('duplicate', () => {
|
|
// it('should duplicate a folder and return the new folder ID', async () => {
|
|
// const userId = '12345';
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const sourceFolder = {title: 'SourceFolder', userId: userId, content: []};
|
|
// const duplicatedFolder = {title: 'SourceFolder (1)', userId: userId, created_at: expect.any(Date), content: []};
|
|
|
|
// // Mock the database responses for the folder and the new folder (first one is found, second one is null)
|
|
// // mock the findOne method
|
|
// jest.spyOn(collection, 'findOne')
|
|
// .mockResolvedValueOnce(sourceFolder) // source file exists
|
|
// .mockResolvedValueOnce(null); // new name is not found
|
|
|
|
// // Mock the folder create method
|
|
// const createSpy = jest.spyOn(folders, 'create').mockResolvedValue(new ObjectId());
|
|
|
|
// // mock the folder.getContent method
|
|
// jest.spyOn(folders, 'getContent').mockResolvedValue([{ title: 'Quiz 1', content: [] }]);
|
|
|
|
// // Mock the quizzes.create method
|
|
// jest.spyOn(quizzes, 'create').mockResolvedValue(new ObjectId());
|
|
|
|
// const result = await folders.duplicate(folderId, userId);
|
|
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
|
|
// // expect folders.create method was called
|
|
// expect(createSpy).toHaveBeenCalledWith(duplicatedFolder.title, userId);
|
|
// // expect the getContent method was called
|
|
// expect(folders.getContent).toHaveBeenCalledWith(folderId);
|
|
// // expect the quizzes.create method was called
|
|
// expect(quizzes.create).toHaveBeenCalledWith('Quiz 1', [], expect.any(String), userId);
|
|
|
|
// expect(result).toBeDefined();
|
|
// });
|
|
|
|
// it('should throw an error if the folder does not exist', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
|
|
// // Mock the database response for the source
|
|
// collection.findOne.mockResolvedValue(null);
|
|
|
|
// await expect(folders.duplicate(folderId, '54321')).rejects.toThrow(`Folder ${folderId} not found`);
|
|
|
|
// // expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.findOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId), userId: '54321' });
|
|
// });
|
|
// });
|
|
|
|
// describe('folderExists', () => {
|
|
// it('should return true if folder exists', async () => {
|
|
// const title = 'Test Folder';
|
|
// const userId = '12345';
|
|
|
|
// // Mock the database response
|
|
// collection.findOne.mockResolvedValue({ title, userId });
|
|
|
|
// const result = await folders.folderExists(title, userId);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.findOne).toHaveBeenCalledWith({ title, userId });
|
|
// expect(result).toBe(true);
|
|
// });
|
|
|
|
// it('should return false if folder does not exist', async () => {
|
|
// const title = 'Nonexistent Folder';
|
|
// const userId = '12345';
|
|
|
|
// // Mock the database response
|
|
// collection.findOne.mockResolvedValue(null);
|
|
|
|
// const result = await folders.folderExists(title, userId);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.findOne).toHaveBeenCalledWith({ title, userId });
|
|
// expect(result).toBe(false);
|
|
// });
|
|
// });
|
|
|
|
// describe('copy', () => {
|
|
// it('should copy a folder and return the new folder ID', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const userId = '12345';
|
|
// const newFolderId = new ObjectId();
|
|
// // Mock some quizzes that are in folder.content
|
|
// const sourceFolder = {
|
|
// title: 'Test Folder',
|
|
// content: [
|
|
// { title: 'Quiz 1', content: [] },
|
|
// { title: 'Quiz 2', content: [] },
|
|
// ],
|
|
// };
|
|
|
|
// // Mock the response from getFolderWithContent
|
|
// jest.spyOn(folders, 'getFolderWithContent').mockResolvedValue(sourceFolder);
|
|
// jest.spyOn(folders, 'create').mockResolvedValue(newFolderId);
|
|
// // Mock the response from Quiz.createQuiz
|
|
// jest.spyOn(quizzes, 'create').mockImplementation(() => {});
|
|
|
|
// const result = await folders.copy(folderId, userId);
|
|
|
|
// // expect(db.connect).toHaveBeenCalled();
|
|
// // expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// // expect(collection.findOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// // expect(collection.insertOne).toHaveBeenCalledWith(expect.objectContaining({ userId }));
|
|
// expect(result).toBe(newFolderId);
|
|
// });
|
|
|
|
// it('should throw an error if the folder does not exist', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const userId = '12345';
|
|
|
|
// // Mock the response from getFolderWithContent
|
|
// jest.spyOn(folders, 'getFolderWithContent').mockImplementation(() => {
|
|
// throw new Error(`Folder ${folderId} not found`);
|
|
// });
|
|
|
|
// await expect(folders.copy(folderId, userId)).rejects.toThrow(`Folder ${folderId} not found`);
|
|
|
|
// // expect(db.connect).toHaveBeenCalled();
|
|
// // expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// // expect(collection.findOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// });
|
|
// });
|
|
|
|
// // write a test for getFolderWithContent
|
|
// describe('getFolderWithContent', () => {
|
|
// it('should return a folder with content', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const folder = {
|
|
// _id: new ObjectId(folderId),
|
|
// title: 'Test Folder',
|
|
// };
|
|
// const content = {
|
|
// content : [
|
|
// { title: 'Quiz 1', content: [] },
|
|
// { title: 'Quiz 2', content: [] },
|
|
// ]};
|
|
|
|
// // Mock the response from getFolderById
|
|
// jest.spyOn(folders, 'getFolderById').mockResolvedValue(folder);
|
|
|
|
// // Mock the response from getContent
|
|
// jest.spyOn(folders, 'getContent').mockResolvedValue(content);
|
|
|
|
// const result = await folders.getFolderWithContent(folderId);
|
|
|
|
// // expect(db.connect).toHaveBeenCalled();
|
|
// // expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// // expect(collection.findOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// expect(result).toEqual({
|
|
// ...folder,
|
|
// content: content
|
|
// });
|
|
// });
|
|
|
|
// it('should throw an error if the folder does not exist', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
|
|
// // // Mock the database response
|
|
// // collection.findOne.mockResolvedValue(null);
|
|
|
|
// // Mock getFolderById to throw an error
|
|
// jest.spyOn(folders, 'getFolderById').mockImplementation(() => {
|
|
// throw new Error(`Folder ${folderId} not found`);
|
|
// });
|
|
|
|
// await expect(folders.getFolderWithContent(folderId)).rejects.toThrow(`Folder ${folderId} not found`);
|
|
|
|
// // expect(db.connect).toHaveBeenCalled();
|
|
// // expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// // expect(collection.findOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// });
|
|
// });
|
|
|
|
// // write a test for getFolderById
|
|
// describe('getFolderById', () => {
|
|
// it('should return a folder by ID', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
// const folder = {
|
|
// _id: new ObjectId(folderId),
|
|
// title: 'Test Folder',
|
|
// };
|
|
|
|
// // Mock the database response
|
|
// collection.findOne.mockResolvedValue(folder);
|
|
|
|
// const result = await folders.getFolderById(folderId);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.findOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// expect(result).toEqual(folder);
|
|
// });
|
|
|
|
// it('should throw an error if the folder does not exist', async () => {
|
|
// const folderId = '60c72b2f9b1d8b3a4c8e4d3b';
|
|
|
|
// // Mock the database response
|
|
// collection.findOne.mockResolvedValue(null);
|
|
|
|
// await expect(folders.getFolderById(folderId)).resolves.toThrow(`Folder ${folderId} not found`);
|
|
|
|
// expect(db.connect).toHaveBeenCalled();
|
|
// expect(db.collection).toHaveBeenCalledWith('folders');
|
|
// expect(collection.findOne).toHaveBeenCalledWith({ _id: new ObjectId(folderId) });
|
|
// });
|
|
// });
|
|
});
|