GitBlog.md/test/app.test.js

const request = require('supertest');
const fs = require('fs');
const path = require('path');
const utils = require('./test_utils');

const dataDir = 'test_data';
const testIndex = 'testindex.ejs';
const testError = 'testerror.ejs';
const testTemplate = 'testtemplate.ejs';

const config = require('../src/config')();

config['test'] = true;
config['data_dir'] = dataDir;
config['webhook']['endpoint'] = '/webhooktest';
config['rss']['endpoint'] = '/rsstest';
config['rss']['length'] = 2;
config['home']['error'] = testError;
config['article']['template'] = testTemplate;
config['modules']['hit_counter'] = false;

const app = require('../src/app')(config);

beforeEach((done, fail) => {
    config['home']['index'] = testIndex;
    config['data_dir'] = dataDir;
    config['article']['index'] = 'index.md';
    config['access_log'] = '';
    config['error_log'] = '';
    config['modules']['rss'] = true;
    config['modules']['webhook'] = true;
    config['modules']['hit_counter'] = false;

    utils.deleteFolderSync(dataDir);
    fs.mkdirSync(dataDir);
    app.reload(done, fail);
});

afterAll(() => {
    if (fs.existsSync(dataDir)) {
        utils.deleteFolderSync(dataDir);
    }
});

describe('Test reload', () => {
    test('reload fail', (done, fail) => {
        config['data_dir'] = '';
        app.reload(fail, done);
    });
});

describe('Test request logging', () => {
    test('no log', (done) => {
        request(app).get('/rsstest')
            .then(() => {
                expect(fs.existsSync(path.join(dataDir, 'access.log'))).toBe(false);
                done();
            });
    });
    test('get 200', (done) => {
        config['access_log'] = path.join(dataDir, 'access.log');
        request(app).get('/rsstest')
            .then(() => {
                fs.readFile(path.join(dataDir, 'access.log'), { encoding: 'UTF-8' }, (err, data) => {
                    expect(err).toBeNull();
                    expect(data).toBe('200 GET /rsstest ' + new Date().toUTCString() + ' ::ffff:127.0.0.1\n');
                    done();
                });
            });
    });
    test('post 400', (done) => {
        config['access_log'] = path.join(dataDir, 'access.log');
        request(app).post('/rsstest')
            .then(() => {
                fs.readFile(path.join(dataDir, 'access.log'), { encoding: 'UTF-8' }, (err, data) => {
                    expect(err).toBeNull();
                    expect(data).toBe('400 POST /rsstest ' + new Date().toUTCString() + ' ::ffff:127.0.0.1\n');
                    done();
                });
            });
    });
    test('2 requests', (done) => {
        config['access_log'] = path.join(dataDir, 'access.log');
        request(app).get('/rss')
            .then(() => {
                request(app).post('/rsstest')
                    .then(() => {
                        fs.readFile(path.join(dataDir, 'access.log'), { encoding: 'UTF-8' }, (err, data) => {
                            expect(err).toBeNull();
                            expect(data).toBe('404 GET /rss ' + new Date().toUTCString() + ' ::ffff:127.0.0.1\n' +
            '400 POST /rsstest ' + new Date().toUTCString() + ' ::ffff:127.0.0.1\n');
                            done();
                        });
                    });
            });
    });
});

describe('Test error logging', () => {
    test('no log', (done) => {
        config['home']['index'] = null;
        request(app).get('/')
            .then(() => {
                expect(fs.existsSync(path.join(dataDir, 'error.log'))).toBe(false);
                done();
            });
    });
    test('null error', (done) => {
        config['home']['index'] = null;
        config['error_log'] = path.join(dataDir, 'error.log');
        request(app).get('/')
            .then(() => {
                fs.readFile(path.join(dataDir, 'error.log'), { encoding: 'UTF-8' }, (err, data) => {
                    expect(err).toBeNull();
                    const start = data.split('\n').slice(0, 2)
                        .join('\n');
                    const expected = '500 GET / ' + new Date().toUTCString() + ' ::ffff:127.0.0.1\nTypeError [ERR_INVALID_ARG_TYPE]: The "path" argument must be of type string.';
                    expect(start.indexOf(expected)).toBe(0);
                    done();
                });
            });
    });
});

describe('Test root path', () => {
    test('404 no index no error', (done) => {
        request(app).get('/')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                done();
            });
    });
    test('404 no index but error page', (done) => {
        fs.writeFileSync(path.join(dataDir, testError), 'error <%= error %>');
        request(app).get('/')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                expect(response.text).toBe('error 404');
                done();
            });
    });
    test('500 render error', (done) => {
        fs.writeFileSync(path.join(dataDir, testIndex), 'articles <%= null.length %>');
        request(app).get('/')
            .then((response) => {
                expect(response.statusCode).toBe(500);
                done();
            });
    });
    test('500 render error with page', (done) => {
        fs.writeFileSync(path.join(dataDir, testIndex), 'articles <%= null.length %>');
        fs.writeFileSync(path.join(dataDir, testError), 'error <%= error %>');
        request(app).get('/')
            .then((response) => {
                expect(response.statusCode).toBe(500);
                expect(response.text).toBe('error 500');
                done();
            });
    });
    test('500 render error with failing page', (done) => {
        fs.writeFileSync(path.join(dataDir, testIndex), 'articles <%= null.length %>');
        fs.writeFileSync(path.join(dataDir, testError), 'error <%= null.error %>');
        request(app).get('/')
            .then((response) => {
                expect(response.statusCode).toBe(500);
                done();
            });
    });
    test('200 no articles', (done) => {
        fs.writeFileSync(path.join(dataDir, testIndex), 'articles <%= articles.length %>');
        request(app).get('/')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                expect(response.text).toBe('articles 0');
                done();
            });
    });
    test('200 2 articles 1 drafted', (done, fail) => {
        utils.createEmptyDirs([
            path.join(dataDir, '2019', '05', '05'),
            path.join(dataDir, '2018', '05', '05'),
            path.join(dataDir, '2017', '05', '05'),
        ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'draft.md'),
            path.join(dataDir, '2018', '05', '05', 'index.md'),
            path.join(dataDir, '2018', '05', '05', 'draft.md'),
            path.join(dataDir, '2017', '05', '05', 'index.md'),
        ]);
        fs.writeFileSync(path.join(dataDir, testIndex), 'articles <%= articles.length %>');
        app.reload(() => {
            request(app).get('/')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.text).toBe('articles 2');
                    done();
                });
        }, fail);
    });
});

describe('Test RSS feed', () => {
    test('404 rss deactivated', (done) => {
        config['modules']['rss'] = false;
        request(app).get('/rsstest')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                done();
            });
    });
    test('200 empty rss', (done) => {
        request(app).get('/rsstest')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                expect(response.type).toBe('application/rss+xml');
                expect(response.text.length).toBeGreaterThan(0);
                expect(response.text.split('<item>').length).toBe(1);
                done();
            });
    });
    test('200 Mozilla fix', (done) => {
        request(app).get('/rsstest')
            .set('user-agent', 'Mozilla Firefox 64.0')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                expect(response.type).toBe('text/xml');
                done();
            });
    });
    test('200 rss cache', (done) => {
        request(app).get('/rsstest')
            .then(() => {
                request(app).get('/rsstest')
                    .then((response) => {
                        expect(response.statusCode).toBe(200);
                        expect(response.text.length).toBeGreaterThan(0);
                        expect(response.text.split('<item>').length).toBe(1);
                        done();
                    });
            });
    });
    test('200 2 rss items', (done, fail) => {
        utils.createEmptyDirs([
            path.join(dataDir, '2019', '05', '05'),
            path.join(dataDir, '2018', '05', '05'),
        ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, '2018', '05', '05', 'index.md'),
        ]);
        app.reload(() => {
            request(app).get('/rsstest')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.text.length).toBeGreaterThan(0);
                    expect(response.text.split('<item>').length).toBe(3);
                    done();
                });
        }, fail);
    });
    test('200 max rss items', (done, fail) => {
        utils.createEmptyDirs([
            path.join(dataDir, '2019', '05', '05'),
            path.join(dataDir, '2018', '05', '05'),
            path.join(dataDir, '2017', '05', '05'),
        ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, '2018', '05', '05', 'index.md'),
            path.join(dataDir, '2017', '05', '05', 'index.md'),
        ]);
        app.reload(() => {
            request(app).get('/rsstest')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.text.length).toBeGreaterThan(0);
                    expect(response.text.split('<item>').length).toBe(3);
                    done();
                });
        }, fail);
    });
});

describe('Test webhook', () => {
    test('400 webhook deactivated', (done) => {
        config['modules']['webhook'] = false;
        request(app).post('/webhooktest')
            .then((response) => {
                expect(response.statusCode).toBe(400);
                done();
            });
    });
    test('200 no secret', (done) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, testTemplate),
        ]);
        config['webhook']['pull_command'] = 'git --help';
        request(app).post('/webhooktest')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                request(app).get('/2019/05/05/')
                    .then((response) => {
                        expect(response.statusCode).toBe(200);
                        done();
                    });
            });
    });
    test('500 command failed', (done) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, testTemplate),
        ]);
        config['webhook']['pull_command'] = 'qzgfqgqz';
        request(app).post('/webhooktest')
            .then((response) => {
                expect(response.statusCode).toBe(500);
                done();
            });
    });
    test('403 wrong secret', (done) => {
        config['webhook']['signature_header'] = 'testheader';
        config['webhook']['secret'] = 'testvalue';
        request(app).post('/webhooktest')
            .set('testheader', 'sha1=invalid')
            .then((response) => {
                expect(response.statusCode).toBe(403);
                done();
            });
    });
    test('200 valid secret', (done) => {
        config['webhook']['signature_header'] = 'testheader';
        config['webhook']['secret'] = 'testvalue';
        config['webhook']['pull_command'] = 'git --help';
        request(app).post('/webhooktest')
            .send({})
            .set('testheader', 'sha1=d924d5bd4b36faf9d572844ac9c12a09ce3e7134')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                done();
            });
    });
});

describe('Test articles rendering', () => {
    test('404 article not found', (done) => {
        request(app).get('/2019/05/06/untitled/')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                done();
            });
    });

    test('500 fail to render', (done, fail) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        fs.writeFileSync(path.join(dataDir, '2019', '05', '05', 'index.md'), '# Hello');
        fs.writeFileSync(path.join(dataDir, testTemplate), '<%- articl.content %><%- `<a href="${article.url}">reload</a>` %>');
        app.reload(() => {
            request(app).get('/2019/05/05/hello/')
                .then((response) => {
                    expect(response.statusCode).toBe(500);
                    done();
                });
        }, fail);
    });

    test('500 no template', (done, fail) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        fs.writeFileSync(path.join(dataDir, '2019', '05', '05', 'index.md'), '# Hello');
        app.reload(() => {
            request(app).get('/2019/05/05/hello/')
                .then((response) => {
                    expect(response.statusCode).toBe(500);
                    done();
                });
        }, fail);
    });

    test('200 rendered article', (done, fail) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        fs.writeFileSync(path.join(dataDir, '2019', '05', '05', 'index.md'), '# Hello');
        fs.writeFileSync(path.join(dataDir, testTemplate), '<%- article.content %><%- `<a href="${article.url}">reload</a>` %>');
        app.reload(() => {
            request(app).get('/2019/05/05/hello/')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.text).toBe('<h1 id="hello">Hello</h1><a href="/2019/05/05/hello/">reload</a>');
                    done();
                });
        }, fail);
    });

    test('200 rendered draft', (done, fail) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        fs.writeFileSync(path.join(dataDir, '2019', '05', '05', 'draft.md'), '# Hello');
        fs.writeFileSync(path.join(dataDir, testTemplate), '<%- article.content %><%- `<a href="${article.url}">reload</a>` %>');
        app.reload(() => {
            request(app).get('/2019/05/05/hello/')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.text).toBe('<h1 id="hello">Hello</h1><a href="/2019/05/05/hello/">reload</a>');
                    done();
                });
        }, fail);
    });

    test('200 other url', (done, fail) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, testTemplate),
        ]);
        app.reload(() => {
            request(app).get('/2019/05/05/anything/')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    done();
                });
        }, fail);
    });

    test('200 other url 2', (done, fail) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, testTemplate),
        ]);
        app.reload(() => {
            request(app).get('/2019/05/05/')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    done();
                });
        }, fail);
    });
});

describe('Test static files', () => {
    test('404 invalid file no error page', (done) => {
        request(app).get('/somefile.txt')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                done();
            });
    });
    test('404 invalid file but error page', (done) => {
        fs.writeFileSync(path.join(dataDir, testError), 'error <%= error %>');
        request(app).get('/somefile.txt')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                expect(response.text).toBe('error 404');
                done();
            });
    });
    test('404 hidden file', (done) => {
        utils.createEmptyDirs([ path.join(dataDir, 'tmp') ]);
        fs.writeFileSync(path.join(dataDir, 'tmp', 'somefile.ejs'), '');
        request(app).get('/tmp/somefile.ejs')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                done();
            });
    });
    test('404 hidden folder', (done) => {
        utils.createEmptyDirs([ path.join(dataDir, '.git') ]);
        fs.writeFileSync(path.join(dataDir, '.git', 'file.txt'), '');
        request(app).get('/.git/file.txt')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                done();
            });
    });
    test('200 valid file', (done) => {
        fs.writeFileSync(path.join(dataDir, 'somefile.css'), 'filecontent');
        request(app).get('/somefile.css')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                expect(response.type).toBe('text/css');
                expect(response.text).toBe('filecontent');
                done();
            });
    });
    test('200 valid resource of article', (done) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        fs.writeFileSync(path.join(dataDir, '2019', '05', '05', 'somefile.txt'), 'filecontent');
        request(app).get('/2019/05/05/title/somefile.txt')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                expect(response.text).toBe('filecontent');
                done();
            });
    });
});

describe('Test other requests', () => {
    test('400 POST', (done) => {
        request(app).post('/')
            .then((response) => {
                expect(response.statusCode).toBe(400);
                done();
            });
    });
    test('400 PUT', (done) => {
        request(app).put('/')
            .then((response) => {
                expect(response.statusCode).toBe(400);
                done();
            });
    });
    test('400 DELETE', (done) => {
        request(app).delete('/')
            .then((response) => {
                expect(response.statusCode).toBe(400);
                done();
            });
    });
});


describe('Test stats', () => {
    test('404 index no stats', (done) => {
        request(app).get('/stats')
            .then((response) => {
                expect(response.statusCode).toBe(404);
                done();
            });
    });
    test('200 index stats', (done) => {
        config['modules']['hit_counter'] = true;
        request(app).get('/stats')
            .then((response) => {
                expect(response.statusCode).toBe(200);
                expect(response.body).toEqual({
                    path: '/',
                    hits: 0,
                    total_visitors: 0,
                    current_visitors: 0,
                });
                done();
            });
    });
    test('200 index stats all no article', (done) => {
        config['modules']['hit_counter'] = true;
        app.reload(() => {
            request(app).get('/stats?all=true')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.body).toEqual([
                        {
                            path: '/',
                            hits: 0,
                            total_visitors: 0,
                            current_visitors: 0,
                        },
                    ]);
                    done();
                });
        });
    });
    test('200 index stats all 2 article 1 drafted', (done) => {
        config['modules']['hit_counter'] = true;
        utils.createEmptyDirs([
            path.join(dataDir, '2019', '05', '05'),
            path.join(dataDir, '2019', '04', '05'),
        ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, '2019', '04', '05', 'draft.md'),
        ]);
        app.reload(() => {
            request(app).get('/stats?all=true')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.body).toEqual([
                        {
                            path: '/',
                            hits: 0,
                            total_visitors: 0,
                            current_visitors: 0,
                        },
                        {
                            path: '2019/05/05',
                            hits: 0,
                            total_visitors: 0,
                            current_visitors: 0,
                        },
                    ]);
                    done();
                });
        });
    });
    test('404 article no stats', (done) => {
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, testTemplate),
        ]);
        app.reload(() => {
            request(app).get('/2019/05/05/hello/stats')
                .then((response) => {
                    expect(response.statusCode).toBe(404);
                    done();
                });
        });
    });
    test('200 article stats', (done) => {
        config['modules']['hit_counter'] = true;
        utils.createEmptyDirs([ path.join(dataDir, '2019', '05', '05') ]);
        utils.createEmptyFiles([
            path.join(dataDir, '2019', '05', '05', 'index.md'),
            path.join(dataDir, testTemplate),
        ]);
        app.reload(() => {
            request(app).get('/2019/05/05/anything/stats')
                .then((response) => {
                    expect(response.statusCode).toBe(200);
                    expect(response.body).toEqual({
                        path: '2019/05/05',
                        hits: 0,
                        total_visitors: 0,
                        current_visitors: 0,
                    });
                    done();
                });
        });
    });
});