.catch(() => {
let user = new Parse.User();
user.setPassword('asdf');
user.setUsername('zxcv');
// Sign up with new email still works
return user.signUp().catch(fail);
})
.catch(() => {
const user = new Parse.User();
user.setPassword('asdf');
user.setUsername('qqq');
user.setEmail('*****@*****.**');
return user.signUp().catch(fail);
})
.catch(error => {
expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
const user = new Parse.User();
user.setPassword('asdf');
user.setUsername('zxcv');
return user.signUp().catch(fail);
})
.then(() => {
let user = new Parse.User();
user.setPassword('asdf');
user.setUsername('u');
// sign up with duplicate username doens't
return user.signUp()
})
it('test save triggers get user', function(done) {
Parse.Cloud.beforeSave('SaveTriggerUser', function(req, res) {
if (req.user && req.user.id) {
res.success();
} else {
res.error('No user present on request object for beforeSave.');
}
});
Parse.Cloud.afterSave('SaveTriggerUser', function(req) {
if (!req.user || !req.user.id) {
console.log('No user present on request object for afterSave.');
}
});
var user = new Parse.User();
user.set("password", "asdf");
user.set("email", "*****@*****.**");
user.set("username", "zxcv");
user.signUp(null, {
success: function() {
var obj = new Parse.Object('SaveTriggerUser');
obj.save().then(function() {
done();
}, function(error) {
fail(error);
done();
});
}
});
});
.then(() => {
const user = new Parse.User();
user.setPassword('asdf');
user.setUsername('www');
user.setEmail('a@b.c');
return user.signUp()
})
it('should handle the User class', function() {
const user = new Parse.User({name: "Turtle"});
return user.save().then((savedUser) => {
return (new Parse.Query(Parse.User).find());
}).then((foundUsers) => {
assert.equal(foundUsers.length, 1);
assert.equal(foundUsers[0].get('name'), "Turtle");
});
});
it('distinct null field', done => {
const options = Object.assign({}, masterKeyOptions, {
body: { distinct: 'distinctField' },
});
const user1 = new Parse.User();
user1.setUsername('distinct_1');
user1.setPassword('password');
user1.set('distinctField', 'one');
const user2 = new Parse.User();
user2.setUsername('distinct_2');
user2.setPassword('password');
user2.set('distinctField', null);
user1
.signUp()
.then(() => {
return user2.signUp();
})
.then(() => {
return get(Parse.serverURL + '/aggregate/_User', options);
})
.then(resp => {
expect(resp.results.length).toEqual(1);
expect(resp.results).toEqual(['one']);
done();
})
.catch(done.fail);
});
.then(() => {
Parse.Cloud.define('checkStaleUser', (request, response) => {
response.success(request.user.get('data'));
});
user = new Parse.User();
user.set('username', 'test');
user.set('password', 'moon-y');
user.set('data', 'first data');
return user.signUp();
})
it('does not return sensitive hidden properties', done => {
const options = Object.assign({}, masterKeyOptions, {
body: {
match: {
score: {
$gt: 5,
},
},
},
});
const username = '******';
const score = 10;
const user = new Parse.User();
user.setUsername(username);
user.setPassword('password');
user.set('score', score);
user
.signUp()
.then(function() {
return get(Parse.serverURL + '/aggregate/_User', options);
})
.then(function(resp) {
expect(resp.results.length).toBe(1);
const result = resp.results[0];
// verify server-side keys are not present...
expect(result._hashed_password).toBe(undefined);
expect(result._wperm).toBe(undefined);
expect(result._rperm).toBe(undefined);
expect(result._acl).toBe(undefined);
expect(result._created_at).toBe(undefined);
expect(result._updated_at).toBe(undefined);
// verify createdAt, updatedAt and others are present
expect(result.createdAt).not.toBe(undefined);
expect(result.updatedAt).not.toBe(undefined);
expect(result.objectId).not.toBe(undefined);
expect(result.username).toBe(username);
expect(result.score).toBe(score);
done();
})
.catch(function(err) {
fail(err);
});
});
success: function(user) {
expect(typeof user.id).toEqual('string');
expect(user.get('password')).toBeUndefined();
expect(user.getSessionToken()).not.toBeUndefined();
Parse.User.logOut();
done();
}, error: function(error) {
beforeEach(function(done) {
restoreServerConfiguration();
Parse.initialize('test', 'test', 'test');
Parse.serverURL = 'http://localhost:' + port + '/1';
Parse.User.enableUnsafeCurrentUser();
return TestUtils.destroyAllDataPermanently().then(done, fail);
});
beforeEach(done => {
try {
Parse.User.enableUnsafeCurrentUser();
} catch (error) {
if (error !== 'You need to call Parse.initialize before using Parse.') {
throw error;
}
}
TestUtils.destroyAllDataPermanently()
.catch(error => {
// For tests that connect to their own mongo, there won't be any data to delete.
if (error.message === 'ns not found' || error.message.startsWith('connect ECONNREFUSED')) {
return;
} else {
fail(error);
return;
}
})
.then(reconfigureServer)
.then(() => {
Parse.initialize('test', 'test', 'test');
Parse.serverURL = 'http://localhost:' + port + '/1';
done();
}, error => {
fail(JSON.stringify(error));
done();
})
});
app.post('/register', bodyParser.urlencoded({ extended: false }), (req, res) => {
// create a user verification string
var email = req.body.email;
// sign up the user
Parse.User.signUp(email, req.body.password, {
// declare extra attributes
}, {
// callback object
success (user) {
// create a hash for the verification link
var toHash = email + user.get("createdAt") + user.id;
var hash = md5(toHash);
var link = "http://*****:*****@gmail.com>',
to: email,
subject: 'Verify Your Email',
html: '<html><h3>Verify Your Email</h3><a href=\"' + link +'\">Click!</a></html>'
};
// fire off the email
mailgun.messages().send(data, (err, body) => {
if (err) console.log(err);
console.log(body);
});
},
error (err) {
console.log(err);
}
});
res.sendFile(__dirname + '/client/index.html');
});
beforeEach(function(done) {
restoreServerConfiguration();
Parse.initialize('test', 'test', 'test');
Parse.serverURL = 'http://localhost:' + port + '/1';
Parse.User.enableUnsafeCurrentUser();
done();
});
constructor(server: any, config: any) {
this.clientId = 0;
this.clients = new Map();
this.subscriptions = new Map();
config = config || {};
// Set LogLevel
PLog.logLevel = config.logLevel || 'INFO';
// Store keys, convert obj to map
let keyPairs = config.keyPairs || {};
this.keyPairs = new Map();
for (let key of Object.keys(keyPairs)) {
this.keyPairs.set(key, keyPairs[key]);
}
PLog.verbose('Support key pairs', this.keyPairs);
// Initialize Parse
Parse.Object.disableSingleInstance();
Parse.User.enableUnsafeCurrentUser();
let serverURL = config.serverURL || Parse.serverURL;
Parse.serverURL = serverURL;
let appId = config.appId || Parse.applicationId;
let javascriptKey = Parse.javaScriptKey;
let masterKey = config.masterKey || Parse.masterKey;
Parse.initialize(appId, javascriptKey, masterKey);
// Initialize websocket server
this.parseWebSocketServer = new ParseWebSocketServer(
server,
(parseWebsocket) => this._onConnect(parseWebsocket),
config.websocketTimeout
);
// Initialize subscriber
this.subscriber = ParsePubSub.createSubscriber({
redisURL: config.redisURL
});
this.subscriber.subscribe('afterSave');
this.subscriber.subscribe('afterDelete');
// Register message handler for subscriber. When publisher get messages, it will publish message
// to the subscribers and the handler will be called.
this.subscriber.on('message', (channel, messageStr) => {
PLog.verbose('Subscribe messsage %j', messageStr);
let message = JSON.parse(messageStr);
this._inflateParseObject(message);
if (channel === 'afterSave') {
this._onAfterSave(message);
} else if (channel === 'afterDelete') {
this._onAfterDelete(message);
} else {
PLog.error('Get message %s from unknown channel %j', message, channel);
}
});
// Initialize sessionToken cache
this.sessionTokenCache = new SessionTokenCache(config.cacheTimeout);
}
user._upgradeToRevocableSession().then((res) => {
expect(res.getSessionToken().indexOf('r:')).toBe(0);
return Parse.User.logOut().then(() => {
return Parse.User.become(res.getSessionToken())
}).then((user) => {
expect(user.id).toEqual('1234567890');
});
}).then(() => {
it('test save triggers get user', function(done) {
var user = new Parse.User();
user.set("password", "asdf");
user.set("email", "*****@*****.**");
user.set("username", "zxcv");
user.signUp(null, {
success: function() {
var obj = new Parse.Object('SaveTriggerUser');
obj.save().then(function() {
done();
}, function(error) {
fail(error);
done();
});
}
});
});
it('should handle redirectClassNameForKey', function() {
const user = new Parse.User({name: "T Rutlidge"});
return user.save().then((savedUser) => {
const roleACL = new Parse.ACL();
roleACL.setPublicReadAccess(true);
const role = new Parse.Role("Turtle", roleACL);
role.getUsers().add(savedUser);
return role.save();
}).then((savedRole) => {
return (new Parse.Query(Parse.Role)).equalTo('name', 'Turtle').first();
}).then((foundRole) => {
return foundRole.getUsers().query().find();
}).then((foundUsers) => {
assert.equal(foundUsers.length, 1);
assert.equal(foundUsers[0].get('name'), "T Rutlidge");
});
});
afterEach(function(done) {
Parse.User.logOut().then(() => {
return clearData();
}).then(() => {
done();
}, (error) => {
console.log('error in clearData', error);
done();
});
});
function createTestUser(success, error) {
var user = new Parse.User();
user.set('username', 'test');
user.set('password', 'moon-y');
var promise = user.signUp();
if (success || error) {
promise.then(function(user) {
if (success) {
success(user);
}
}, function(err) {
if (error) {
error(err);
}
});
} else {
return promise;
}
}
afterEach(function(done) {
Parse.User.logOut().then(() => {
return TestUtils.destroyAllDataPermanently();
}).then(() => {
done();
}, (error) => {
console.log('error in clearData', error);
done();
});
});
it('ensure that email is uniquely indexed', done => {
let Promise = require('bluebird');
let numFailed = 0;
let numCreated = 0;
const user1 = new Parse.User();
user1.setPassword('asdf');
user1.setUsername('u1');
user1.setEmail('*****@*****.**');
const p1 = user1.signUp();
p1.then(() => {
numCreated++;
expect(numCreated).toEqual(1);
return Promise.delay(100);
}, error => {
numFailed++;
expect(numFailed).toEqual(1);
expect(error.code).toEqual(Parse.Error.EMAIL_TAKEN);
});
const user2 = new Parse.User();
user2.setPassword('asdf');
user2.setUsername('u2');
user2.setEmail('*****@*****.**');
const p2 = user2.signUp();
p2.then(() => {
numCreated++;
expect(numCreated).toEqual(1);
return Promise.delay(100);
}, error => {
numFailed++;
expect(numFailed).toEqual(1);
expect(error.code).toEqual(Parse.Error.EMAIL_TAKEN);
});
Parse.Promise.when([p1, p2])
.then(() => {
fail('one of the users should not have been created');
done();
})
.catch(done);
});
afterEach(function(done) {
restoreServerConfiguration();
Parse.User.logOut().then(() => {
return clearData();
}).then(() => {
DatabaseAdapter.clearDatabaseURIs();
done();
}, (error) => {
console.log('error in clearData', error);
done();
});
});
success: function(producer) {
// Creates a new User in the Parse database
var user = new Parse.User();
user.set("username", req.body.email);
user.set("password", req.body.password);
user.set("email", req.body.email);
user.set("producer", producer);
user.signUp(null, {
success: function(user) {
// Hooray! Let them use the app now.
// Sets a user session cookie to expire in 30 days
// The Parse.Session is automatically created and linked to this user
res.cookie('presence', user.getSessionToken(), { maxAge: 2592000000 });
// req.cookies['presence'];
res.redirect('/farm/' + producer.id);
},
error: function(user, error) {
// The signup failed. Check error to see why.
// Destroy the producer entry
producer.destroy({});
// Show the error message somewhere and let the user try again.
logError(error);
res.render('error', {message: error.message, error: error});
}
});
},
function createUser(req,res,next){
var user = new Parse.User();
let username = new Rnd().generate();
let password = "******";
user.set('username',username);
user.set('password',password);
user.signUp(null, {
success: function(user) {
debug("user created: " + user.id)
loadUserSettings(req,res,next,user)
},
error: function(user, error) {
req.app.set('response', "Error: " + error.code + " " + error.message);
next();
}
});
}
const Register = (req: Request, res: Response, next: NextFunction) => {
logger.debug(`in register...${JSON.stringify(req.body)}`);
const newUser = new Parse.User();
Object.keys(req.body).forEach((key) => {
newUser.set(key, req.body[key]);
});
// Default type to client
newUser.set('type', GCUserRole.CLIENT);
newUser.signUp(null, {
success: (user) => {
logger.debug(`sign up successfully...${JSON.stringify(user)}`);
const userInfo = GCUser.simplifyParseObject(user);
res.status(200).json(userInfo);
},
error: (user, error) => {
logger.debug(`sign up failed...${user} - ${error.code} - ${error.message} - ${Config.PARSE_SERVER_URL} - ${Config.PARSE_APP_ID}`);
res.status(400).send('Fail...');
},
});
};
.then(() => {
const user = new Parse.User();
user.setPassword('asdf');
user.setUsername('2');
user.setEmail('2@b.c');
user.set('randomField', 'a');
return user.signUp()
})
createTestUser(function(u) {
expect(typeof u.id).toEqual('string');
Parse.User.logIn('test', 'moon-y', {
success: function(user) {
expect(typeof user.id).toEqual('string');
expect(user.get('password')).toBeUndefined();
expect(user.getSessionToken()).not.toBeUndefined();
Parse.User.logOut().then(done);
}, error: function(error) {
fail(error);
}
});
}, fail);
getUserId(sessionToken: string): any {
if (!sessionToken) {
return Parse.Promise.error('Empty sessionToken');
}
let userId = this.cache.get(sessionToken);
if (userId) {
PLog.verbose('Fetch userId %s of sessionToken %s from Cache', userId, sessionToken);
return Parse.Promise.as(userId);
}
return Parse.User.become(sessionToken).then((user) => {
PLog.verbose('Fetch userId %s of sessionToken %s from Parse', user.id, sessionToken);
let userId = user.id;
this.cache.set(sessionToken, userId);
return Parse.Promise.as(userId);
}, (error) => {
PLog.error('Can not fetch userId for sessionToken %j, error %j', sessionToken, error);
return Parse.Promise.error(error);
});
}