.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); }); }