394 lines
14 KiB
JavaScript
394 lines
14 KiB
JavaScript
const LoggerController = require('../lib/Controllers/LoggerController').LoggerController;
|
|
const WinstonLoggerAdapter = require('../lib/Adapters/Logger/WinstonLoggerAdapter')
|
|
.WinstonLoggerAdapter;
|
|
const fs = require('fs');
|
|
const Config = require('../lib/Config');
|
|
|
|
const loremFile = __dirname + '/support/lorem.txt';
|
|
|
|
describe('Cloud Code Logger', () => {
|
|
let user;
|
|
let spy;
|
|
beforeEach(async () => {
|
|
Parse.User.enableUnsafeCurrentUser();
|
|
return reconfigureServer({
|
|
// useful to flip to false for fine tuning :).
|
|
silent: true,
|
|
logLevel: undefined,
|
|
logLevels: {
|
|
cloudFunctionError: 'error',
|
|
cloudFunctionSuccess: 'info',
|
|
triggerAfter: 'info',
|
|
triggerBeforeError: 'error',
|
|
triggerBeforeSuccess: 'info',
|
|
},
|
|
})
|
|
.then(() => {
|
|
return Parse.User.signUp('tester', 'abc')
|
|
.catch(() => {})
|
|
.then(loggedInUser => (user = loggedInUser))
|
|
.then(() => Parse.User.logIn(user.get('username'), 'abc'));
|
|
})
|
|
.then(() => {
|
|
spy = spyOn(Config.get('test').loggerController.adapter, 'log').and.callThrough();
|
|
});
|
|
});
|
|
|
|
// Note that helpers takes care of logout.
|
|
// see helpers.js:afterEach
|
|
|
|
it('should expose log to functions', () => {
|
|
const spy = spyOn(Config.get('test').loggerController, 'log').and.callThrough();
|
|
Parse.Cloud.define('loggerTest', req => {
|
|
req.log.info('logTest', 'info log', { info: 'some log' });
|
|
req.log.error('logTest', 'error log', { error: 'there was an error' });
|
|
return {};
|
|
});
|
|
|
|
return Parse.Cloud.run('loggerTest').then(() => {
|
|
expect(spy).toHaveBeenCalledTimes(3);
|
|
const cloudFunctionMessage = spy.calls.all()[2];
|
|
const errorMessage = spy.calls.all()[1];
|
|
const infoMessage = spy.calls.all()[0];
|
|
expect(cloudFunctionMessage.args[0]).toBe('info');
|
|
expect(cloudFunctionMessage.args[1][1].params).toEqual({});
|
|
expect(cloudFunctionMessage.args[1][0]).toMatch(
|
|
/Ran cloud function loggerTest for user [^ ]* with:\n {2}Input: {}\n {2}Result: {}/
|
|
);
|
|
expect(cloudFunctionMessage.args[1][1].functionName).toEqual('loggerTest');
|
|
expect(errorMessage.args[0]).toBe('error');
|
|
expect(errorMessage.args[1][2].error).toBe('there was an error');
|
|
expect(errorMessage.args[1][0]).toBe('logTest');
|
|
expect(errorMessage.args[1][1]).toBe('error log');
|
|
expect(infoMessage.args[0]).toBe('info');
|
|
expect(infoMessage.args[1][2].info).toBe('some log');
|
|
expect(infoMessage.args[1][0]).toBe('logTest');
|
|
expect(infoMessage.args[1][1]).toBe('info log');
|
|
});
|
|
});
|
|
|
|
it('trigger should obfuscate password', done => {
|
|
Parse.Cloud.beforeSave(Parse.User, req => {
|
|
return req.object;
|
|
});
|
|
|
|
Parse.User.signUp('tester123', 'abc')
|
|
.then(() => {
|
|
const entry = spy.calls.mostRecent().args;
|
|
expect(entry[1]).not.toMatch(/password":"abc/);
|
|
expect(entry[1]).toMatch(/\*\*\*\*\*\*\*\*/);
|
|
done();
|
|
})
|
|
.then(null, e => done.fail(e));
|
|
});
|
|
|
|
it('should expose log to trigger', done => {
|
|
Parse.Cloud.beforeSave('MyObject', req => {
|
|
req.log.info('beforeSave MyObject', 'info log', { info: 'some log' });
|
|
req.log.error('beforeSave MyObject', 'error log', {
|
|
error: 'there was an error',
|
|
});
|
|
return {};
|
|
});
|
|
|
|
const obj = new Parse.Object('MyObject');
|
|
obj.save().then(() => {
|
|
const lastCalls = spy.calls.all().reverse();
|
|
const cloudTriggerMessage = lastCalls[0].args;
|
|
const errorMessage = lastCalls[1].args;
|
|
const infoMessage = lastCalls[2].args;
|
|
expect(cloudTriggerMessage[0]).toBe('info');
|
|
expect(cloudTriggerMessage[2].triggerType).toEqual('beforeSave');
|
|
expect(cloudTriggerMessage[1]).toMatch(
|
|
/beforeSave triggered for MyObject for user [^ ]*\n {2}Input: {}\n {2}Result: {"object":{}}/
|
|
);
|
|
expect(cloudTriggerMessage[2].user).toBe(user.id);
|
|
expect(errorMessage[0]).toBe('error');
|
|
expect(errorMessage[3].error).toBe('there was an error');
|
|
expect(errorMessage[1] + ' ' + errorMessage[2]).toBe('beforeSave MyObject error log');
|
|
expect(infoMessage[0]).toBe('info');
|
|
expect(infoMessage[3].info).toBe('some log');
|
|
expect(infoMessage[1] + ' ' + infoMessage[2]).toBe('beforeSave MyObject info log');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should truncate really long lines when asked to', () => {
|
|
const logController = new LoggerController(new WinstonLoggerAdapter());
|
|
const longString = fs.readFileSync(loremFile, 'utf8');
|
|
const truncatedString = logController.truncateLogMessage(longString);
|
|
expect(truncatedString.length).toBe(1015); // truncate length + the string '... (truncated)'
|
|
});
|
|
|
|
it('should truncate input and result of long lines', done => {
|
|
const longString = fs.readFileSync(loremFile, 'utf8');
|
|
Parse.Cloud.define('aFunction', req => {
|
|
return req.params;
|
|
});
|
|
|
|
Parse.Cloud.run('aFunction', { longString })
|
|
.then(() => {
|
|
const log = spy.calls.mostRecent().args;
|
|
expect(log[0]).toEqual('info');
|
|
expect(log[1]).toMatch(
|
|
/Ran cloud function aFunction for user [^ ]* with:\n {2}Input: {.*?\(truncated\)$/m
|
|
);
|
|
done();
|
|
})
|
|
.then(null, e => done.fail(e));
|
|
});
|
|
|
|
it('should log an afterSave', done => {
|
|
Parse.Cloud.afterSave('MyObject', () => {});
|
|
new Parse.Object('MyObject')
|
|
.save()
|
|
.then(() => {
|
|
const log = spy.calls.mostRecent().args;
|
|
expect(log[2].triggerType).toEqual('afterSave');
|
|
done();
|
|
})
|
|
// catch errors - not that the error is actually useful :(
|
|
.then(null, e => done.fail(e));
|
|
});
|
|
|
|
it('should log a denied beforeSave', done => {
|
|
Parse.Cloud.beforeSave('MyObject', () => {
|
|
throw 'uh oh!';
|
|
});
|
|
|
|
new Parse.Object('MyObject')
|
|
.save()
|
|
.then(
|
|
() => done.fail('this is not supposed to succeed'),
|
|
() => new Promise(resolve => setTimeout(resolve, 100))
|
|
)
|
|
.then(() => {
|
|
const logs = spy.calls.all().reverse();
|
|
const log = logs[1].args; // 0 is the 'uh oh!' from rejection...
|
|
expect(log[0]).toEqual('error');
|
|
const error = log[2].error;
|
|
expect(error instanceof Parse.Error).toBeTruthy();
|
|
expect(error.code).toBe(Parse.Error.SCRIPT_FAILED);
|
|
expect(error.message).toBe('uh oh!');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should log cloud function success', done => {
|
|
Parse.Cloud.define('aFunction', () => {
|
|
return 'it worked!';
|
|
});
|
|
|
|
Parse.Cloud.run('aFunction', { foo: 'bar' }).then(() => {
|
|
const log = spy.calls.mostRecent().args;
|
|
expect(log[0]).toEqual('info');
|
|
expect(log[1]).toMatch(
|
|
/Ran cloud function aFunction for user [^ ]* with:\n {2}Input: {"foo":"bar"}\n {2}Result: "it worked!/
|
|
);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should log cloud function execution using the custom log level', async done => {
|
|
Parse.Cloud.define('aFunction', () => {
|
|
return 'it worked!';
|
|
});
|
|
|
|
Parse.Cloud.define('bFunction', () => {
|
|
throw new Error('Failed');
|
|
});
|
|
|
|
await Parse.Cloud.run('aFunction', { foo: 'bar' }).then(() => {
|
|
const log = spy.calls.allArgs().find(log => log[1].startsWith('Ran cloud function '))?.[0];
|
|
expect(log).toEqual('info');
|
|
});
|
|
|
|
await reconfigureServer({
|
|
silent: true,
|
|
logLevels: {
|
|
cloudFunctionSuccess: 'warn',
|
|
cloudFunctionError: 'info',
|
|
},
|
|
});
|
|
|
|
spy = spyOn(Config.get('test').loggerController.adapter, 'log').and.callThrough();
|
|
|
|
try {
|
|
await Parse.Cloud.run('bFunction', { foo: 'bar' });
|
|
throw new Error('bFunction should have failed');
|
|
} catch {
|
|
const log = spy.calls
|
|
.allArgs()
|
|
.find(log => log[1].startsWith('Failed running cloud function bFunction for '))?.[0];
|
|
expect(log).toEqual('info');
|
|
done();
|
|
}
|
|
});
|
|
|
|
it('should log cloud function triggers using the custom log level', async () => {
|
|
Parse.Cloud.beforeSave('TestClass', () => {});
|
|
Parse.Cloud.afterSave('TestClass', () => {});
|
|
|
|
const execTest = async (logLevel, triggerBeforeSuccess, triggerAfter) => {
|
|
await reconfigureServer({
|
|
silent: true,
|
|
logLevel,
|
|
logLevels: {
|
|
triggerAfter,
|
|
triggerBeforeSuccess,
|
|
},
|
|
});
|
|
|
|
spy = spyOn(Config.get('test').loggerController.adapter, 'log').and.callThrough();
|
|
const obj = new Parse.Object('TestClass');
|
|
await obj.save();
|
|
|
|
return {
|
|
beforeSave: spy.calls
|
|
.allArgs()
|
|
.find(log => log[1].startsWith('beforeSave triggered for TestClass for user '))?.[0],
|
|
afterSave: spy.calls
|
|
.allArgs()
|
|
.find(log => log[1].startsWith('afterSave triggered for TestClass for user '))?.[0],
|
|
};
|
|
};
|
|
|
|
let calls = await execTest('silly', 'silly', 'debug');
|
|
expect(calls).toEqual({ beforeSave: 'silly', afterSave: 'debug' });
|
|
|
|
calls = await execTest('info', 'warn', 'debug');
|
|
expect(calls).toEqual({ beforeSave: 'warn', afterSave: undefined });
|
|
});
|
|
|
|
it('should log cloud function failure', done => {
|
|
Parse.Cloud.define('aFunction', () => {
|
|
throw 'it failed!';
|
|
});
|
|
|
|
Parse.Cloud.run('aFunction', { foo: 'bar' })
|
|
.catch(() => {})
|
|
.then(() => {
|
|
const logs = spy.calls.all().reverse();
|
|
expect(logs[0].args[1]).toBe('Parse error: ');
|
|
expect(logs[0].args[2].message).toBe('it failed!');
|
|
|
|
const log = logs[1].args;
|
|
expect(log[0]).toEqual('error');
|
|
expect(log[1]).toMatch(
|
|
/Failed running cloud function aFunction for user [^ ]* with:\n {2}Input: {"foo":"bar"}\n {2}Error:/
|
|
);
|
|
const errorString = JSON.stringify(
|
|
new Parse.Error(Parse.Error.SCRIPT_FAILED, 'it failed!')
|
|
);
|
|
expect(log[1].indexOf(errorString)).toBeGreaterThan(0);
|
|
done();
|
|
})
|
|
.catch(done.fail);
|
|
});
|
|
|
|
xit('should log a changed beforeSave indicating a change', done => {
|
|
const logController = new LoggerController(new WinstonLoggerAdapter());
|
|
|
|
Parse.Cloud.beforeSave('MyObject', req => {
|
|
const myObj = req.object;
|
|
myObj.set('aChange', true);
|
|
return myObj;
|
|
});
|
|
|
|
new Parse.Object('MyObject')
|
|
.save()
|
|
.then(() => logController.getLogs({ from: Date.now() - 500, size: 1000 }))
|
|
.then(() => {
|
|
// expect the log to indicate that it has changed
|
|
/*
|
|
Here's what it looks like on parse.com...
|
|
|
|
Input: {"original":{"clientVersion":"1","createdAt":"2016-06-02T05:29:08.694Z","image":{"__type":"File","name":"tfss-xxxxxxxx.png","url":"http://files.parsetfss.com/xxxxxxxx.png"},"lastScanDate":{"__type":"Date","iso":"2016-06-02T05:28:58.135Z"},"localIdentifier":"XXXXX","objectId":"OFHMX7ZUcI","status":... (truncated)
|
|
Result: Update changed to {"object":{"__type":"Pointer","className":"Emoticode","objectId":"ksrq7z3Ehc"},"imageThumb":{"__type":"File","name":"tfss-xxxxxxx.png","url":"http://files.parsetfss.com/xxxxx.png"},"status":"success"}
|
|
*/
|
|
done();
|
|
})
|
|
.then(null, e => done.fail(JSON.stringify(e)));
|
|
}).pend('needs more work.....');
|
|
|
|
it('cloud function should obfuscate password', done => {
|
|
Parse.Cloud.define('testFunction', () => {
|
|
return 'verify code success';
|
|
});
|
|
|
|
Parse.Cloud.run('testFunction', { username: 'hawk', password: '123456' })
|
|
.then(() => {
|
|
const entry = spy.calls.mostRecent().args;
|
|
expect(entry[2].params.password).toMatch(/\*\*\*\*\*\*\*\*/);
|
|
done();
|
|
})
|
|
.then(null, e => done.fail(e));
|
|
});
|
|
|
|
it('should only log once for object not found', async () => {
|
|
const config = Config.get('test');
|
|
const spy = spyOn(config.loggerController, 'error').and.callThrough();
|
|
try {
|
|
const object = new Parse.Object('Object');
|
|
object.id = 'invalid';
|
|
await object.fetch();
|
|
} catch (e) {
|
|
/**/
|
|
}
|
|
expect(spy).toHaveBeenCalled();
|
|
expect(spy.calls.count()).toBe(1);
|
|
const { args } = spy.calls.mostRecent();
|
|
expect(args[0]).toBe('Parse error: ');
|
|
expect(args[1].message).toBe('Object not found.');
|
|
});
|
|
|
|
it('should log cloud function execution using the silent log level', async () => {
|
|
await reconfigureServer({
|
|
logLevels: {
|
|
cloudFunctionSuccess: 'silent',
|
|
cloudFunctionError: 'silent',
|
|
},
|
|
});
|
|
Parse.Cloud.define('aFunction', () => {
|
|
return 'it worked!';
|
|
});
|
|
Parse.Cloud.define('bFunction', () => {
|
|
throw new Error('Failed');
|
|
});
|
|
spy = spyOn(Config.get('test').loggerController.adapter, 'log').and.callThrough();
|
|
|
|
await Parse.Cloud.run('aFunction', { foo: 'bar' });
|
|
expect(spy).toHaveBeenCalledTimes(0);
|
|
|
|
await expectAsync(Parse.Cloud.run('bFunction', { foo: 'bar' })).toBeRejected();
|
|
// Not "Failed running cloud function message..."
|
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('should log cloud function triggers using the silent log level', async () => {
|
|
await reconfigureServer({
|
|
logLevels: {
|
|
triggerAfter: 'silent',
|
|
triggerBeforeSuccess: 'silent',
|
|
triggerBeforeError: 'silent',
|
|
},
|
|
});
|
|
Parse.Cloud.beforeSave('TestClassError', () => {
|
|
throw new Error('Failed');
|
|
});
|
|
Parse.Cloud.beforeSave('TestClass', () => {});
|
|
Parse.Cloud.afterSave('TestClass', () => {});
|
|
|
|
spy = spyOn(Config.get('test').loggerController.adapter, 'log').and.callThrough();
|
|
|
|
const obj = new Parse.Object('TestClass');
|
|
await obj.save();
|
|
expect(spy).toHaveBeenCalledTimes(0);
|
|
|
|
const objError = new Parse.Object('TestClassError');
|
|
await expectAsync(objError.save()).toBeRejected();
|
|
// Not "beforeSave failed for TestClassError for user ..."
|
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|