Unit and integration test of Express REST API and multer single file update middleware

Introduction

Hello everybody,

I'm pretty new to unit and integration testing. The current REST API I'm working on involves file uploads and file system. If you want me to explain what's API this is, I can explain it to you using few sentences. Imagine a system like Microsoft Word. There are only users and users have documents. Users' documents are only JSON files and they are able to upload JSON file to add a document. My API currently has 3 routes, 2 middlewares.

Routes:

• auth.js (authorization route)
• documents.js (document centered CRUD operations)
• users.js

Middlewares:

• auth.js (To check if there is valid JSON web token to continue)
• uploadFile.js (To upload single file using multer)

I have been able to unit/integration test auth.js, users.js routes and auth.js middleware. These routes and middlewares were only involving small packages of data I/O, so they were pretty easy for me. But documents.js router and uploadFile.js middleware is pretty hard for me to overcome.

Let me share my problems.

Source codes

documents.js Router

.
.
.
router.post('/mine', [auth, uploadFile], async (req, res) => {
    const user = await User.findById(req.user._id);

    user.leftDiskSpace(function(err, leftSpace) {
        if(err) {
            return res.status(400).send(createError(err.message, 400));
        } else {
            if(leftSpace < 0) {
                fs.access(req.file.path, (err) => {
                    if(err) {
                        res.status(403).send(createError('Your plan\'s disk space is exceeded.', 403));
                    } else {
                        fs.unlink(req.file.path, (err) => {
                            if(err) res.status(500).send('Silinmek istenen doküman diskten silinemedi.');
                            else res.status(403).send(createError('Your plan\'s disk space is exceeded.', 403));
                        });
                    }
                });
            } else {
                let document = new Document({
                    filename: req.file.filename,
                    path: `/uploads/${req.user.username}/${req.file.filename}`,
                    size: req.file.size
                });
        
                document.save()
                    .then((savedDocument) => {
                        user.documents.push(savedDocument._id);
                        user.save()
                            .then(() => res.send(savedDocument));
                    });
            }
        }
    });
});
.
.
.

uploadFile.js Middleware

const fs = require('fs');
const path = require('path');
const createError = require('./../helpers/createError');
const jsonFileFilter = require('./../helpers/jsonFileFilter');
const multer = require('multer');

const storage = multer.diskStorage({
    destination: function(req, file, cb) {
        console.log('file: ', file);
        if(!req.user.username) return cb(new Error('Dokümanın yükleneceği klasör için isim belirtilmemiş.'), null);
        let uploadDestination = path.join(process.cwd(), 'uploads', req.user.username);
        fs.access(uploadDestination, (err) => {
            if(err) {
                // Directory with username doesn't exist in uploads folder, so create one
                fs.mkdir(uploadDestination, (err) => {
                    if(err) cb(err, null);
                    cb(null, uploadDestination);
                });
            } else {
                // Directory with username exists
                cb(null, uploadDestination);
            }
        });
    },
    filename: function(req, file, cb) {
        cb(null, `${file.originalname.replace('.json', '')}--${Date.now()}.json`);
    }
});

module.exports = function(req, res, next) {
    multer({ storage: storage, fileFilter: jsonFileFilter }).single('document')(req, res, function(err) {
        if(req.fileValidationError) return res.status(400).send(createError(req.fileValidationError.message, 400));
        else if(!req.file) return res.status(400).send(createError('Herhangi bir doküman seçilmedi.', 400));
        else if(err instanceof multer.MulterError) return res.status(500).send(createError(err.message, 500));
        else if(err) return res.status(500).send(createError(err, 500));
        else next();
    });
}

Questions

1. How can I test user.leftDiskSpace(function(err, leftSpace) { ... }); function which has a callback and contains some Node.js fs methods which also has callbacks?

I want to reach branches and statements user.leftDiskSpace() function containing. I thought of using mock functions to mock out the function but I don't know how to do so.

2. How to change multer disk storage's upload destination for a specified testing folder?

Currently my API uploads the test documents to development/production uploads disk storage destination. What is the best way to change upload destination for testing? I thought to use NODE_ENV global variable to check if the API is being tested or not and change destination in uploadFile.js middleware but I'm not sure if it's a good solution of this problem. What should I do?

Current documents.test.js file

const request = require('supertest');
const { Document } = require('../../../models/document');
const { User } = require('../../../models/user');
const mongoose = require('mongoose');
const path = require('path');

let server;

describe('/api/documents', () => {
    beforeEach(() => { server = require('../../../bin/www'); });
    afterEach(async () => {
        server.close();
        await User.deleteMany({});
        await Document.deleteMany({});
    });

    .
    .
    .
    describe('POST /mine', () => {
        let user;
        let token;
        let file;

        const exec = async () => {
            return await request(server)
                .post('/api/documents/mine')
                .set('x-auth-token', token)
                .attach('document', file);
        }

        beforeEach(async () => {
            user = new User({
                username: 'user',
                password: '1234'
            });
            await user.save();

            token = user.generateAuthToken();

            file = path.join(process.cwd(), 'tests', 'integration', 'files', 'test.json');
        });

        it('should return 400 if no documents attached', async () => {
            file = undefined;

            const res = await exec();

            expect(res.status).toBe(400);
        });

        it('should return 400 if a non-JSON document attached', async () => {
            file = path.join(process.cwd(), 'tests', 'integration', 'files', 'test.png');

            const res = await exec();

            expect(res.status).toBe(400);
        });
    });
});