1596 lines
49 KiB
JavaScript
1596 lines
49 KiB
JavaScript
// This is a port of the test suite:
|
|
// hungry/js/test/parse_user_test.js
|
|
//
|
|
// Things that we didn't port:
|
|
// Tests that involve revocable sessions.
|
|
// Tests that involve sending password reset emails.
|
|
|
|
var request = require('request');
|
|
var crypto = require('../crypto');
|
|
|
|
describe('Parse.User testing', () => {
|
|
it("user sign up class method", (done) => {
|
|
Parse.User.signUp("asdf", "zxcv", null, {
|
|
success: function(user) {
|
|
ok(user.getSessionToken());
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user sign up instance method", (done) => {
|
|
var user = new Parse.User();
|
|
user.setPassword("asdf");
|
|
user.setUsername("zxcv");
|
|
user.signUp(null, {
|
|
success: function(user) {
|
|
ok(user.getSessionToken());
|
|
done();
|
|
},
|
|
error: function(userAgain, error) {
|
|
ok(undefined, error);
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user login wrong username", (done) => {
|
|
Parse.User.signUp("asdf", "zxcv", null, {
|
|
success: function(user) {
|
|
Parse.User.logIn("non_existent_user", "asdf3",
|
|
expectError(Parse.Error.OBJECT_NOT_FOUND, done));
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user login wrong password", (done) => {
|
|
Parse.User.signUp("asdf", "zxcv", null, {
|
|
success: function(user) {
|
|
Parse.User.logIn("asdf", "asdfWrong",
|
|
expectError(Parse.Error.OBJECT_NOT_FOUND, done));
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user login", (done) => {
|
|
Parse.User.signUp("asdf", "zxcv", null, {
|
|
success: function(user) {
|
|
Parse.User.logIn("asdf", "zxcv", {
|
|
success: function(user) {
|
|
equal(user.get("username"), "asdf");
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("become", (done) => {
|
|
var user = null;
|
|
var sessionToken = null;
|
|
|
|
Parse.Promise.as().then(function() {
|
|
return Parse.User.signUp("Jason", "Parse", { "code": "red" });
|
|
|
|
}).then(function(newUser) {
|
|
equal(Parse.User.current(), newUser);
|
|
|
|
user = newUser;
|
|
sessionToken = newUser.getSessionToken();
|
|
ok(sessionToken);
|
|
|
|
Parse.User.logOut();
|
|
ok(!Parse.User.current());
|
|
|
|
return Parse.User.become(sessionToken);
|
|
|
|
}).then(function(newUser) {
|
|
equal(Parse.User.current(), newUser);
|
|
|
|
ok(newUser);
|
|
equal(newUser.id, user.id);
|
|
equal(newUser.get("username"), "Jason");
|
|
equal(newUser.get("code"), "red");
|
|
|
|
Parse.User.logOut();
|
|
ok(!Parse.User.current());
|
|
|
|
return Parse.User.become("somegarbage");
|
|
|
|
}).then(function() {
|
|
// This should have failed actually.
|
|
ok(false, "Shouldn't have been able to log in with garbage session token.");
|
|
}, function(error) {
|
|
ok(error);
|
|
// Handle the error.
|
|
return Parse.Promise.as();
|
|
|
|
}).then(function() {
|
|
done();
|
|
}, function(error) {
|
|
ok(false, error);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("cannot save non-authed user", (done) => {
|
|
var user = new Parse.User();
|
|
user.set({
|
|
"password": "asdf",
|
|
"email": "asdf@example.com",
|
|
"username": "zxcv"
|
|
});
|
|
user.signUp(null, {
|
|
success: function(userAgain) {
|
|
equal(userAgain, user);
|
|
var query = new Parse.Query(Parse.User);
|
|
query.get(user.id, {
|
|
success: function(userNotAuthed) {
|
|
user = new Parse.User();
|
|
user.set({
|
|
"username": "hacker",
|
|
"password": "password"
|
|
});
|
|
user.signUp(null, {
|
|
success: function(userAgain) {
|
|
equal(userAgain, user);
|
|
userNotAuthed.set("username", "changed");
|
|
userNotAuthed.save().then(fail, (err) => {
|
|
expect(err.code).toEqual(Parse.Error.SESSION_MISSING);
|
|
done();
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(undefined, error);
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(undefined, error);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("cannot delete non-authed user", (done) => {
|
|
var user = new Parse.User();
|
|
user.signUp({
|
|
"password": "asdf",
|
|
"email": "asdf@example.com",
|
|
"username": "zxcv"
|
|
}, {
|
|
success: function() {
|
|
var query = new Parse.Query(Parse.User);
|
|
query.get(user.id, {
|
|
success: function(userNotAuthed) {
|
|
user = new Parse.User();
|
|
user.signUp({
|
|
"username": "hacker",
|
|
"password": "password"
|
|
}, {
|
|
success: function(userAgain) {
|
|
equal(userAgain, user);
|
|
userNotAuthed.set("username", "changed");
|
|
userNotAuthed.destroy(expectError(
|
|
Parse.Error.SESSION_MISSING, done));
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("cannot saveAll with non-authed user", (done) => {
|
|
var user = new Parse.User();
|
|
user.signUp({
|
|
"password": "asdf",
|
|
"email": "asdf@example.com",
|
|
"username": "zxcv"
|
|
}, {
|
|
success: function() {
|
|
var query = new Parse.Query(Parse.User);
|
|
query.get(user.id, {
|
|
success: function(userNotAuthed) {
|
|
user = new Parse.User();
|
|
user.signUp({
|
|
username: "hacker",
|
|
password: "password"
|
|
}, {
|
|
success: function() {
|
|
query.get(user.id, {
|
|
success: function(userNotAuthedNotChanged) {
|
|
userNotAuthed.set("username", "changed");
|
|
var object = new TestObject();
|
|
object.save({
|
|
user: userNotAuthedNotChanged
|
|
}, {
|
|
success: function(object) {
|
|
var item1 = new TestObject();
|
|
item1.save({
|
|
number: 0
|
|
}, {
|
|
success: function(item1) {
|
|
item1.set("number", 1);
|
|
var item2 = new TestObject();
|
|
item2.set("number", 2);
|
|
Parse.Object.saveAll(
|
|
[item1, item2, userNotAuthed],
|
|
expectError(Parse.Error.SESSION_MISSING, done));
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("current user", (done) => {
|
|
var user = new Parse.User();
|
|
user.set("password", "asdf");
|
|
user.set("email", "asdf@example.com");
|
|
user.set("username", "zxcv");
|
|
user.signUp(null, {
|
|
success: function() {
|
|
var currentUser = Parse.User.current();
|
|
equal(user.id, currentUser.id);
|
|
ok(user.getSessionToken());
|
|
|
|
var currentUserAgain = Parse.User.current();
|
|
// should be the same object
|
|
equal(currentUser, currentUserAgain);
|
|
|
|
// test logging out the current user
|
|
Parse.User.logOut();
|
|
|
|
equal(Parse.User.current(), null);
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user.isCurrent", (done) => {
|
|
var user1 = new Parse.User();
|
|
var user2 = new Parse.User();
|
|
var user3 = new Parse.User();
|
|
|
|
user1.set("username", "a");
|
|
user2.set("username", "b");
|
|
user3.set("username", "c");
|
|
|
|
user1.set("password", "password");
|
|
user2.set("password", "password");
|
|
user3.set("password", "password");
|
|
|
|
user1.signUp(null, {
|
|
success: function () {
|
|
equal(user1.isCurrent(), true);
|
|
equal(user2.isCurrent(), false);
|
|
equal(user3.isCurrent(), false);
|
|
user2.signUp(null, {
|
|
success: function() {
|
|
equal(user1.isCurrent(), false);
|
|
equal(user2.isCurrent(), true);
|
|
equal(user3.isCurrent(), false);
|
|
user3.signUp(null, {
|
|
success: function() {
|
|
equal(user1.isCurrent(), false);
|
|
equal(user2.isCurrent(), false);
|
|
equal(user3.isCurrent(), true);
|
|
Parse.User.logIn("a", "password", {
|
|
success: function(user1) {
|
|
equal(user1.isCurrent(), true);
|
|
equal(user2.isCurrent(), false);
|
|
equal(user3.isCurrent(), false);
|
|
Parse.User.logIn("b", "password", {
|
|
success: function(user2) {
|
|
equal(user1.isCurrent(), false);
|
|
equal(user2.isCurrent(), true);
|
|
equal(user3.isCurrent(), false);
|
|
Parse.User.logIn("b", "password", {
|
|
success: function(user3) {
|
|
equal(user1.isCurrent(), false);
|
|
equal(user2.isCurrent(), true);
|
|
equal(user3.isCurrent(), true);
|
|
Parse.User.logOut();
|
|
equal(user3.isCurrent(), false);
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user associations", (done) => {
|
|
var child = new TestObject();
|
|
child.save(null, {
|
|
success: function() {
|
|
var user = new Parse.User();
|
|
user.set("password", "asdf");
|
|
user.set("email", "asdf@example.com");
|
|
user.set("username", "zxcv");
|
|
user.set("child", child);
|
|
user.signUp(null, {
|
|
success: function() {
|
|
var object = new TestObject();
|
|
object.set("user", user);
|
|
object.save(null, {
|
|
success: function() {
|
|
var query = new Parse.Query(TestObject);
|
|
query.get(object.id, {
|
|
success: function(objectAgain) {
|
|
var userAgain = objectAgain.get("user");
|
|
userAgain.fetch({
|
|
success: function() {
|
|
equal(user.id, userAgain.id);
|
|
equal(userAgain.get("child").id, child.id);
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user queries", (done) => {
|
|
var user = new Parse.User();
|
|
user.set("password", "asdf");
|
|
user.set("email", "asdf@example.com");
|
|
user.set("username", "zxcv");
|
|
user.signUp(null, {
|
|
success: function() {
|
|
var query = new Parse.Query(Parse.User);
|
|
query.get(user.id, {
|
|
success: function(userAgain) {
|
|
equal(userAgain.id, user.id);
|
|
query.find({
|
|
success: function(users) {
|
|
equal(users.length, 1);
|
|
equal(users[0].id, user.id);
|
|
ok(userAgain.get("email"), "asdf@example.com");
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
function signUpAll(list, optionsOrCallback) {
|
|
var promise = Parse.Promise.as();
|
|
list.forEach((user) => {
|
|
promise = promise.then(function() {
|
|
return user.signUp();
|
|
});
|
|
});
|
|
promise = promise.then(function() { return list; });
|
|
return promise._thenRunCallbacks(optionsOrCallback);
|
|
}
|
|
|
|
it("contained in user array queries", (done) => {
|
|
var USERS = 4;
|
|
var MESSAGES = 5;
|
|
|
|
// Make a list of users.
|
|
var userList = range(USERS).map(function(i) {
|
|
var user = new Parse.User();
|
|
user.set("password", "user_num_" + i);
|
|
user.set("email", "user_num_" + i + "@example.com");
|
|
user.set("username", "xinglblog_num_" + i);
|
|
return user;
|
|
});
|
|
|
|
signUpAll(userList, function(users) {
|
|
// Make a list of messages.
|
|
var messageList = range(MESSAGES).map(function(i) {
|
|
var message = new TestObject();
|
|
message.set("to", users[(i + 1) % USERS]);
|
|
message.set("from", users[i % USERS]);
|
|
return message;
|
|
});
|
|
|
|
// Save all the messages.
|
|
Parse.Object.saveAll(messageList, function(messages) {
|
|
|
|
// Assemble an "in" list.
|
|
var inList = [users[0], users[3], users[3]]; // Intentional dupe
|
|
var query = new Parse.Query(TestObject);
|
|
query.containedIn("from", inList);
|
|
query.find({
|
|
success: function(results) {
|
|
equal(results.length, 3);
|
|
done();
|
|
}
|
|
});
|
|
|
|
});
|
|
});
|
|
});
|
|
|
|
it("saving a user signs them up but doesn't log them in", (done) => {
|
|
var user = new Parse.User();
|
|
user.save({
|
|
password: "asdf",
|
|
email: "asdf@example.com",
|
|
username: "zxcv"
|
|
}, {
|
|
success: function() {
|
|
equal(Parse.User.current(), null);
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user updates", (done) => {
|
|
var user = new Parse.User();
|
|
user.signUp({
|
|
password: "asdf",
|
|
email: "asdf@example.com",
|
|
username: "zxcv"
|
|
}, {
|
|
success: function(user) {
|
|
user.set("username", "test");
|
|
user.save(null, {
|
|
success: function() {
|
|
equal(Object.keys(user.attributes).length, 6);
|
|
ok(user.attributes["username"]);
|
|
ok(user.attributes["email"]);
|
|
user.destroy({
|
|
success: function() {
|
|
var query = new Parse.Query(Parse.User);
|
|
query.get(user.id, {
|
|
error: function(model, error) {
|
|
// The user should no longer exist.
|
|
equal(error.code, Parse.Error.OBJECT_NOT_FOUND);
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(undefined, error);
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(undefined, error);
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(undefined, error);
|
|
}
|
|
});
|
|
});
|
|
|
|
it("count users", (done) => {
|
|
var james = new Parse.User();
|
|
james.set("username", "james");
|
|
james.set("password", "mypass");
|
|
james.signUp(null, {
|
|
success: function() {
|
|
var kevin = new Parse.User();
|
|
kevin.set("username", "kevin");
|
|
kevin.set("password", "mypass");
|
|
kevin.signUp(null, {
|
|
success: function() {
|
|
var query = new Parse.Query(Parse.User);
|
|
query.count({
|
|
success: function(count) {
|
|
equal(count, 2);
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user sign up with container class", (done) => {
|
|
Parse.User.signUp("ilya", "mypass", { "array": ["hello"] }, {
|
|
success: function() {
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user modified while saving", (done) => {
|
|
Parse.Object.disableSingleInstance();
|
|
var user = new Parse.User();
|
|
user.set("username", "alice");
|
|
user.set("password", "password");
|
|
user.signUp(null, {
|
|
success: function(userAgain) {
|
|
equal(userAgain.get("username"), "bob");
|
|
ok(userAgain.dirty("username"));
|
|
var query = new Parse.Query(Parse.User);
|
|
query.get(user.id, {
|
|
success: function(freshUser) {
|
|
equal(freshUser.id, user.id);
|
|
equal(freshUser.get("username"), "alice");
|
|
Parse.Object.enableSingleInstance();
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
ok(user.set("username", "bob"));
|
|
});
|
|
|
|
it("user modified while saving with unsaved child", (done) => {
|
|
Parse.Object.disableSingleInstance();
|
|
var user = new Parse.User();
|
|
user.set("username", "alice");
|
|
user.set("password", "password");
|
|
user.set("child", new TestObject());
|
|
user.signUp(null, {
|
|
success: function(userAgain) {
|
|
equal(userAgain.get("username"), "bob");
|
|
// Should be dirty, but it depends on batch support.
|
|
// ok(userAgain.dirty("username"));
|
|
var query = new Parse.Query(Parse.User);
|
|
query.get(user.id, {
|
|
success: function(freshUser) {
|
|
equal(freshUser.id, user.id);
|
|
// Should be alice, but it depends on batch support.
|
|
equal(freshUser.get("username"), "bob");
|
|
Parse.Object.enableSingleInstance();
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
ok(user.set("username", "bob"));
|
|
});
|
|
|
|
it("user loaded from localStorage from signup", (done) => {
|
|
Parse.User.signUp("alice", "password", null, {
|
|
success: function(alice) {
|
|
ok(alice.id, "Alice should have an objectId");
|
|
ok(alice.getSessionToken(), "Alice should have a session token");
|
|
equal(alice.get("password"), undefined,
|
|
"Alice should not have a password");
|
|
|
|
// Simulate the environment getting reset.
|
|
Parse.User._currentUser = null;
|
|
Parse.User._currentUserMatchesDisk = false;
|
|
|
|
var aliceAgain = Parse.User.current();
|
|
equal(aliceAgain.get("username"), "alice");
|
|
equal(aliceAgain.id, alice.id, "currentUser should have objectId");
|
|
ok(aliceAgain.getSessionToken(),
|
|
"currentUser should have a sessionToken");
|
|
equal(alice.get("password"), undefined,
|
|
"currentUser should not have password");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
|
|
it("user loaded from localStorage from login", (done) => {
|
|
|
|
Parse.User.signUp("alice", "password", null, {
|
|
success: function(alice) {
|
|
var id = alice.id;
|
|
Parse.User.logOut();
|
|
|
|
Parse.User.logIn("alice", "password", {
|
|
success: function(user) {
|
|
// Force the current user to read from disk
|
|
delete Parse.User._currentUser;
|
|
delete Parse.User._currentUserMatchesDisk;
|
|
|
|
var userFromDisk = Parse.User.current();
|
|
equal(userFromDisk.get("password"), undefined,
|
|
"password should not be in attributes");
|
|
equal(userFromDisk.id, id, "id should be set");
|
|
ok(userFromDisk.getSessionToken(),
|
|
"currentUser should have a sessionToken");
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
it("saving user after browser refresh", (done) => {
|
|
var _ = Parse._;
|
|
var id;
|
|
|
|
Parse.User.signUp("alice", "password", null).then(function(alice) {
|
|
id = alice.id;
|
|
Parse.User.logOut();
|
|
|
|
return Parse.User.logIn("alice", "password");
|
|
}).then(function() {
|
|
// Simulate browser refresh by force-reloading user from localStorage
|
|
Parse.User._clearCache();
|
|
|
|
// Test that this save works correctly
|
|
return Parse.User.current().save({some_field: 1});
|
|
}).then(function() {
|
|
// Check the user in memory just after save operation
|
|
var userInMemory = Parse.User.current();
|
|
|
|
equal(userInMemory.getUsername(), "alice",
|
|
"saving user should not remove existing fields");
|
|
|
|
equal(userInMemory.get('some_field'), 1,
|
|
"saving user should save specified field");
|
|
|
|
equal(userInMemory.get("password"), undefined,
|
|
"password should not be in attributes after saving user");
|
|
|
|
equal(userInMemory.get("objectId"), undefined,
|
|
"objectId should not be in attributes after saving user");
|
|
|
|
equal(userInMemory.get("_id"), undefined,
|
|
"_id should not be in attributes after saving user");
|
|
|
|
equal(userInMemory.id, id, "id should be set");
|
|
|
|
expect(userInMemory.updatedAt instanceof Date).toBe(true);
|
|
|
|
ok(userInMemory.createdAt instanceof Date);
|
|
|
|
ok(userInMemory.getSessionToken(),
|
|
"user should have a sessionToken after saving");
|
|
|
|
// Force the current user to read from localStorage, and check again
|
|
delete Parse.User._currentUser;
|
|
delete Parse.User._currentUserMatchesDisk;
|
|
var userFromDisk = Parse.User.current();
|
|
|
|
equal(userFromDisk.getUsername(), "alice",
|
|
"userFromDisk should have previously existing fields");
|
|
|
|
equal(userFromDisk.get('some_field'), 1,
|
|
"userFromDisk should have saved field");
|
|
|
|
equal(userFromDisk.get("password"), undefined,
|
|
"password should not be in attributes of userFromDisk");
|
|
|
|
equal(userFromDisk.get("objectId"), undefined,
|
|
"objectId should not be in attributes of userFromDisk");
|
|
|
|
equal(userFromDisk.get("_id"), undefined,
|
|
"_id should not be in attributes of userFromDisk");
|
|
|
|
equal(userFromDisk.id, id, "id should be set on userFromDisk");
|
|
|
|
ok(userFromDisk.updatedAt instanceof Date);
|
|
|
|
ok(userFromDisk.createdAt instanceof Date);
|
|
|
|
ok(userFromDisk.getSessionToken(),
|
|
"userFromDisk should have a sessionToken");
|
|
|
|
done();
|
|
}, function(error) {
|
|
ok(false, error);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("user with missing username", (done) => {
|
|
var user = new Parse.User();
|
|
user.set("password", "foo");
|
|
user.signUp(null, {
|
|
success: function() {
|
|
ok(null, "This should have failed");
|
|
done();
|
|
},
|
|
error: function(userAgain, error) {
|
|
equal(error.code, Parse.Error.OTHER_CAUSE);
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user with missing password", (done) => {
|
|
var user = new Parse.User();
|
|
user.set("username", "foo");
|
|
user.signUp(null, {
|
|
success: function() {
|
|
ok(null, "This should have failed");
|
|
done();
|
|
},
|
|
error: function(userAgain, error) {
|
|
equal(error.code, Parse.Error.OTHER_CAUSE);
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user stupid subclassing", (done) => {
|
|
|
|
var SuperUser = Parse.Object.extend("User");
|
|
var user = new SuperUser();
|
|
user.set("username", "bob");
|
|
user.set("password", "welcome");
|
|
ok(user instanceof Parse.User, "Subclassing User should have worked");
|
|
user.signUp(null, {
|
|
success: function() {
|
|
done();
|
|
},
|
|
error: function() {
|
|
ok(false, "Signing up should have worked");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user signup class method uses subclassing", (done) => {
|
|
|
|
var SuperUser = Parse.User.extend({
|
|
secret: function() {
|
|
return 1337;
|
|
}
|
|
});
|
|
|
|
Parse.User.signUp("bob", "welcome", null, {
|
|
success: function(user) {
|
|
ok(user instanceof SuperUser, "Subclassing User should have worked");
|
|
equal(user.secret(), 1337);
|
|
done();
|
|
},
|
|
error: function() {
|
|
ok(false, "Signing up should have worked");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("user on disk gets updated after save", (done) => {
|
|
|
|
var SuperUser = Parse.User.extend({
|
|
isSuper: function() {
|
|
return true;
|
|
}
|
|
});
|
|
|
|
Parse.User.signUp("bob", "welcome", null, {
|
|
success: function(user) {
|
|
// Modify the user and save.
|
|
user.save("secret", 1337, {
|
|
success: function() {
|
|
// Force the current user to read from disk
|
|
delete Parse.User._currentUser;
|
|
delete Parse.User._currentUserMatchesDisk;
|
|
|
|
var userFromDisk = Parse.User.current();
|
|
equal(userFromDisk.get("secret"), 1337);
|
|
ok(userFromDisk.isSuper(), "The subclass should have been used");
|
|
done();
|
|
},
|
|
error: function() {
|
|
ok(false, "Saving should have worked");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function() {
|
|
ok(false, "Sign up should have worked");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("current user isn't dirty", (done) => {
|
|
|
|
Parse.User.signUp("andrew", "oppa", { style: "gangnam" }, expectSuccess({
|
|
success: function(user) {
|
|
ok(!user.dirty("style"), "The user just signed up.");
|
|
Parse.User._currentUser = null;
|
|
Parse.User._currentUserMatchesDisk = false;
|
|
var userAgain = Parse.User.current();
|
|
ok(!userAgain.dirty("style"), "The user was just read from disk.");
|
|
done();
|
|
}
|
|
}));
|
|
});
|
|
|
|
// Note that this mocks out client-side Facebook action rather than
|
|
// server-side.
|
|
var getMockFacebookProvider = function() {
|
|
return {
|
|
userId: "8675309",
|
|
authToken: "jenny",
|
|
expiration: new Date().toJSON(),
|
|
shouldError: false,
|
|
loggedOut: false,
|
|
synchronizedUserId: null,
|
|
synchronizedAuthToken: null,
|
|
synchronizedExpiration: null,
|
|
|
|
authenticate: function(options) {
|
|
if (this.shouldError) {
|
|
options.error(this, "An error occurred");
|
|
} else if (this.shouldCancel) {
|
|
options.error(this, null);
|
|
} else {
|
|
options.success(this, {
|
|
id: this.userId,
|
|
access_token: this.authToken,
|
|
expiration_date: this.expiration
|
|
});
|
|
}
|
|
},
|
|
restoreAuthentication: function(authData) {
|
|
if (!authData) {
|
|
this.synchronizedUserId = null;
|
|
this.synchronizedAuthToken = null;
|
|
this.synchronizedExpiration = null;
|
|
return true;
|
|
}
|
|
this.synchronizedUserId = authData.id;
|
|
this.synchronizedAuthToken = authData.access_token;
|
|
this.synchronizedExpiration = authData.expiration_date;
|
|
return true;
|
|
},
|
|
getAuthType: function() {
|
|
return "facebook";
|
|
},
|
|
deauthenticate: function() {
|
|
this.loggedOut = true;
|
|
this.restoreAuthentication(null);
|
|
}
|
|
};
|
|
};
|
|
|
|
var ExtendedUser = Parse.User.extend({
|
|
extended: function() {
|
|
return true;
|
|
}
|
|
});
|
|
|
|
it("log in with provider", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
Parse.User._logInWith("facebook", {
|
|
success: function(model) {
|
|
ok(model instanceof Parse.User, "Model should be a Parse.User");
|
|
strictEqual(Parse.User.current(), model);
|
|
ok(model.extended(), "Should have used subclass.");
|
|
strictEqual(provider.userId, provider.synchronizedUserId);
|
|
strictEqual(provider.authToken, provider.synchronizedAuthToken);
|
|
strictEqual(provider.expiration, provider.synchronizedExpiration);
|
|
ok(model._isLinked("facebook"), "User should be linked to facebook");
|
|
done();
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "linking should have worked");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("log in with provider twice", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
Parse.User._logInWith("facebook", {
|
|
success: function(model) {
|
|
ok(model instanceof Parse.User, "Model should be a Parse.User");
|
|
strictEqual(Parse.User.current(), model);
|
|
ok(model.extended(), "Should have used the subclass.");
|
|
strictEqual(provider.userId, provider.synchronizedUserId);
|
|
strictEqual(provider.authToken, provider.synchronizedAuthToken);
|
|
strictEqual(provider.expiration, provider.synchronizedExpiration);
|
|
ok(model._isLinked("facebook"), "User should be linked to facebook");
|
|
|
|
Parse.User.logOut();
|
|
ok(provider.loggedOut);
|
|
provider.loggedOut = false;
|
|
|
|
Parse.User._logInWith("facebook", {
|
|
success: function(innerModel) {
|
|
ok(innerModel instanceof Parse.User,
|
|
"Model should be a Parse.User");
|
|
ok(innerModel === Parse.User.current(),
|
|
"Returned model should be the current user");
|
|
ok(provider.userId === provider.synchronizedUserId);
|
|
ok(provider.authToken === provider.synchronizedAuthToken);
|
|
ok(innerModel._isLinked("facebook"),
|
|
"User should be linked to facebook");
|
|
ok(innerModel.existed(), "User should not be newly-created");
|
|
done();
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "LogIn should have worked");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "LogIn should have worked");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("log in with provider failed", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
provider.shouldError = true;
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
Parse.User._logInWith("facebook", {
|
|
success: function(model) {
|
|
ok(false, "logIn should not have succeeded");
|
|
},
|
|
error: function(model, error) {
|
|
ok(error, "Error should be non-null");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("log in with provider cancelled", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
provider.shouldCancel = true;
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
Parse.User._logInWith("facebook", {
|
|
success: function(model) {
|
|
ok(false, "logIn should not have succeeded");
|
|
},
|
|
error: function(model, error) {
|
|
ok(error === null, "Error should be null");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("link with provider", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
var user = new Parse.User();
|
|
user.set("username", "testLinkWithProvider");
|
|
user.set("password", "mypass");
|
|
user.signUp(null, {
|
|
success: function(model) {
|
|
user._linkWith("facebook", {
|
|
success: function(model) {
|
|
ok(model instanceof Parse.User, "Model should be a Parse.User");
|
|
strictEqual(Parse.User.current(), model);
|
|
strictEqual(provider.userId, provider.synchronizedUserId);
|
|
strictEqual(provider.authToken, provider.synchronizedAuthToken);
|
|
strictEqual(provider.expiration, provider.synchronizedExpiration);
|
|
ok(model._isLinked("facebook"), "User should be linked");
|
|
done();
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "linking should have succeeded");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "signup should not have failed");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
// What this means is, only one Parse User can be linked to a
|
|
// particular Facebook account.
|
|
it("link with provider for already linked user", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
var user = new Parse.User();
|
|
user.set("username", "testLinkWithProviderToAlreadyLinkedUser");
|
|
user.set("password", "mypass");
|
|
user.signUp(null, {
|
|
success: function(model) {
|
|
user._linkWith("facebook", {
|
|
success: function(model) {
|
|
ok(model instanceof Parse.User, "Model should be a Parse.User");
|
|
strictEqual(Parse.User.current(), model);
|
|
strictEqual(provider.userId, provider.synchronizedUserId);
|
|
strictEqual(provider.authToken, provider.synchronizedAuthToken);
|
|
strictEqual(provider.expiration, provider.synchronizedExpiration);
|
|
ok(model._isLinked("facebook"), "User should be linked.");
|
|
var user2 = new Parse.User();
|
|
user2.set("username", "testLinkWithProviderToAlreadyLinkedUser2");
|
|
user2.set("password", "mypass");
|
|
user2.signUp(null, {
|
|
success: function(model) {
|
|
user2._linkWith('facebook', {
|
|
success: fail,
|
|
error: function(model, error) {
|
|
expect(error.code).toEqual(
|
|
Parse.Error.ACCOUNT_ALREADY_LINKED);
|
|
done();
|
|
},
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "linking should have failed");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "linking should have succeeded");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "signup should not have failed");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("link with provider failed", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
provider.shouldError = true;
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
var user = new Parse.User();
|
|
user.set("username", "testLinkWithProvider");
|
|
user.set("password", "mypass");
|
|
user.signUp(null, {
|
|
success: function(model) {
|
|
user._linkWith("facebook", {
|
|
success: function(model) {
|
|
ok(false, "linking should fail");
|
|
done();
|
|
},
|
|
error: function(model, error) {
|
|
ok(error, "Linking should fail");
|
|
ok(!model._isLinked("facebook"),
|
|
"User should not be linked to facebook");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "signup should not have failed");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("link with provider cancelled", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
provider.shouldCancel = true;
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
var user = new Parse.User();
|
|
user.set("username", "testLinkWithProvider");
|
|
user.set("password", "mypass");
|
|
user.signUp(null, {
|
|
success: function(model) {
|
|
user._linkWith("facebook", {
|
|
success: function(model) {
|
|
ok(false, "linking should fail");
|
|
done();
|
|
},
|
|
error: function(model, error) {
|
|
ok(!error, "Linking should be cancelled");
|
|
ok(!model._isLinked("facebook"),
|
|
"User should not be linked to facebook");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "signup should not have failed");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("unlink with provider", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
Parse.User._logInWith("facebook", {
|
|
success: function(model) {
|
|
ok(model instanceof Parse.User, "Model should be a Parse.User.");
|
|
strictEqual(Parse.User.current(), model);
|
|
ok(model.extended(), "Should have used the subclass.");
|
|
strictEqual(provider.userId, provider.synchronizedUserId);
|
|
strictEqual(provider.authToken, provider.synchronizedAuthToken);
|
|
strictEqual(provider.expiration, provider.synchronizedExpiration);
|
|
ok(model._isLinked("facebook"), "User should be linked to facebook.");
|
|
|
|
model._unlinkFrom("facebook", {
|
|
success: function(model) {
|
|
ok(!model._isLinked("facebook"), "User should not be linked.");
|
|
ok(!provider.synchronizedUserId, "User id should be cleared.");
|
|
ok(!provider.synchronizedAuthToken,
|
|
"Auth token should be cleared.");
|
|
ok(!provider.synchronizedExpiration,
|
|
"Expiration should be cleared.");
|
|
done();
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "unlinking should succeed");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "linking should have worked");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it("unlink and link", (done) => {
|
|
var provider = getMockFacebookProvider();
|
|
Parse.User._registerAuthenticationProvider(provider);
|
|
Parse.User._logInWith("facebook", {
|
|
success: function(model) {
|
|
ok(model instanceof Parse.User, "Model should be a Parse.User");
|
|
strictEqual(Parse.User.current(), model);
|
|
ok(model.extended(), "Should have used the subclass.");
|
|
strictEqual(provider.userId, provider.synchronizedUserId);
|
|
strictEqual(provider.authToken, provider.synchronizedAuthToken);
|
|
strictEqual(provider.expiration, provider.synchronizedExpiration);
|
|
ok(model._isLinked("facebook"), "User should be linked to facebook");
|
|
|
|
model._unlinkFrom("facebook", {
|
|
success: function(model) {
|
|
ok(!model._isLinked("facebook"),
|
|
"User should not be linked to facebook");
|
|
ok(!provider.synchronizedUserId, "User id should be cleared");
|
|
ok(!provider.synchronizedAuthToken, "Auth token should be cleared");
|
|
ok(!provider.synchronizedExpiration,
|
|
"Expiration should be cleared");
|
|
|
|
model._linkWith("facebook", {
|
|
success: function(model) {
|
|
ok(provider.synchronizedUserId, "User id should have a value");
|
|
ok(provider.synchronizedAuthToken,
|
|
"Auth token should have a value");
|
|
ok(provider.synchronizedExpiration,
|
|
"Expiration should have a value");
|
|
ok(model._isLinked("facebook"),
|
|
"User should be linked to facebook");
|
|
done();
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "linking again should succeed");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "unlinking should succeed");
|
|
done();
|
|
}
|
|
});
|
|
},
|
|
error: function(model, error) {
|
|
ok(false, "linking should have worked");
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
it('set password then change password', (done) => {
|
|
Parse.User.signUp('bob', 'barker').then((bob) => {
|
|
bob.setPassword('meower');
|
|
return bob.save();
|
|
}).then(() => {
|
|
return Parse.User.logIn('bob', 'meower');
|
|
}).then((bob) => {
|
|
expect(bob.getUsername()).toEqual('bob');
|
|
done();
|
|
}, (e) => {
|
|
console.log(e);
|
|
fail();
|
|
});
|
|
});
|
|
|
|
it("authenticated check", (done) => {
|
|
var user = new Parse.User();
|
|
user.set("username", "darkhelmet");
|
|
user.set("password", "onetwothreefour");
|
|
ok(!user.authenticated());
|
|
user.signUp(null, expectSuccess({
|
|
success: function(result) {
|
|
ok(user.authenticated());
|
|
done();
|
|
}
|
|
}));
|
|
});
|
|
|
|
it("log in with explicit facebook auth data", (done) => {
|
|
Parse.FacebookUtils.logIn({
|
|
id: "8675309",
|
|
access_token: "jenny",
|
|
expiration_date: new Date().toJSON()
|
|
}, expectSuccess({success: done}));
|
|
});
|
|
|
|
it("log in async with explicit facebook auth data", (done) => {
|
|
Parse.FacebookUtils.logIn({
|
|
id: "8675309",
|
|
access_token: "jenny",
|
|
expiration_date: new Date().toJSON()
|
|
}).then(function() {
|
|
done();
|
|
}, function(error) {
|
|
ok(false, error);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("link with explicit facebook auth data", (done) => {
|
|
Parse.User.signUp("mask", "open sesame", null, expectSuccess({
|
|
success: function(user) {
|
|
Parse.FacebookUtils.link(user, {
|
|
id: "8675309",
|
|
access_token: "jenny",
|
|
expiration_date: new Date().toJSON()
|
|
}).then(done, (error) => {
|
|
fail(error);
|
|
done();
|
|
});
|
|
}
|
|
}));
|
|
});
|
|
|
|
it("link async with explicit facebook auth data", (done) => {
|
|
Parse.User.signUp("mask", "open sesame", null, expectSuccess({
|
|
success: function(user) {
|
|
Parse.FacebookUtils.link(user, {
|
|
id: "8675309",
|
|
access_token: "jenny",
|
|
expiration_date: new Date().toJSON()
|
|
}).then(function() {
|
|
done();
|
|
}, function(error) {
|
|
ok(false, error);
|
|
done();
|
|
});
|
|
}
|
|
}));
|
|
});
|
|
|
|
it("async methods", (done) => {
|
|
var data = { foo: "bar" };
|
|
|
|
Parse.User.signUp("finn", "human", data).then(function(user) {
|
|
equal(Parse.User.current(), user);
|
|
equal(user.get("foo"), "bar");
|
|
return Parse.User.logOut();
|
|
}).then(function() {
|
|
return Parse.User.logIn("finn", "human");
|
|
}).then(function(user) {
|
|
equal(user, Parse.User.current());
|
|
equal(user.get("foo"), "bar");
|
|
return Parse.User.logOut();
|
|
}).then(function() {
|
|
var user = new Parse.User();
|
|
user.set("username", "jake");
|
|
user.set("password", "dog");
|
|
user.set("foo", "baz");
|
|
return user.signUp();
|
|
}).then(function(user) {
|
|
equal(user, Parse.User.current());
|
|
equal(user.get("foo"), "baz");
|
|
user = new Parse.User();
|
|
user.set("username", "jake");
|
|
user.set("password", "dog");
|
|
return user.logIn();
|
|
}).then(function(user) {
|
|
equal(user, Parse.User.current());
|
|
equal(user.get("foo"), "baz");
|
|
var userAgain = new Parse.User();
|
|
userAgain.id = user.id;
|
|
return userAgain.fetch();
|
|
}).then(function(userAgain) {
|
|
equal(userAgain.get("foo"), "baz");
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("querying for users doesn't get session tokens", (done) => {
|
|
Parse.Promise.as().then(function() {
|
|
return Parse.User.signUp("finn", "human", { foo: "bar" });
|
|
|
|
}).then(function() {
|
|
Parse.User.logOut();
|
|
|
|
var user = new Parse.User();
|
|
user.set("username", "jake");
|
|
user.set("password", "dog");
|
|
user.set("foo", "baz");
|
|
return user.signUp();
|
|
|
|
}).then(function() {
|
|
Parse.User.logOut();
|
|
|
|
var query = new Parse.Query(Parse.User);
|
|
return query.find();
|
|
|
|
}).then(function(users) {
|
|
equal(users.length, 2);
|
|
for (var user of users) {
|
|
ok(!user.getSessionToken(), "user should not have a session token.");
|
|
}
|
|
|
|
done();
|
|
}, function(error) {
|
|
ok(false, error);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("querying for users only gets the expected fields", (done) => {
|
|
Parse.Promise.as().then(() => {
|
|
return Parse.User.signUp("finn", "human", { foo: "bar" });
|
|
}).then(() => {
|
|
request.get({
|
|
headers: {'X-Parse-Application-Id': 'test',
|
|
'X-Parse-REST-API-Key': 'rest'},
|
|
url: 'http://localhost:8378/1/users',
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
expect(b.results.length).toEqual(1);
|
|
var user = b.results[0];
|
|
expect(Object.keys(user).length).toEqual(5);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
it('user save should fail with invalid email', (done) => {
|
|
var user = new Parse.User();
|
|
user.set('username', 'teste');
|
|
user.set('password', 'test');
|
|
user.set('email', 'invalid');
|
|
user.signUp().then(() => {
|
|
fail('Should not have been able to save.');
|
|
done();
|
|
}, (error) => {
|
|
expect(error.code).toEqual(125);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('user signup should error if email taken', (done) => {
|
|
var user = new Parse.User();
|
|
user.set('username', 'test1');
|
|
user.set('password', 'test');
|
|
user.set('email', 'test@test.com');
|
|
user.signUp().then(() => {
|
|
var user2 = new Parse.User();
|
|
user2.set('username', 'test2');
|
|
user2.set('password', 'test');
|
|
user2.set('email', 'test@test.com');
|
|
return user2.signUp();
|
|
}).then(() => {
|
|
fail('Should not have been able to sign up.');
|
|
done();
|
|
}, (error) => {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('user cannot update email to existing user', (done) => {
|
|
var user = new Parse.User();
|
|
user.set('username', 'test1');
|
|
user.set('password', 'test');
|
|
user.set('email', 'test@test.com');
|
|
user.signUp().then(() => {
|
|
var user2 = new Parse.User();
|
|
user2.set('username', 'test2');
|
|
user2.set('password', 'test');
|
|
return user2.signUp();
|
|
}).then((user2) => {
|
|
user2.set('email', 'test@test.com');
|
|
return user2.save();
|
|
}).then(() => {
|
|
fail('Should not have been able to sign up.');
|
|
done();
|
|
}, (error) => {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('create session from user', (done) => {
|
|
Parse.Promise.as().then(() => {
|
|
return Parse.User.signUp("finn", "human", { foo: "bar" });
|
|
}).then((user) => {
|
|
request.post({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken(),
|
|
'X-Parse-REST-API-Key': 'rest'
|
|
},
|
|
url: 'http://localhost:8378/1/sessions',
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
expect(typeof b.sessionToken).toEqual('string');
|
|
expect(typeof b.createdWith).toEqual('object');
|
|
expect(b.createdWith.action).toEqual('create');
|
|
expect(typeof b.user).toEqual('object');
|
|
expect(b.user.objectId).toEqual(user.id);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
it('user get session from token', (done) => {
|
|
Parse.Promise.as().then(() => {
|
|
return Parse.User.signUp("finn", "human", { foo: "bar" });
|
|
}).then((user) => {
|
|
request.get({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken(),
|
|
'X-Parse-REST-API-Key': 'rest'
|
|
},
|
|
url: 'http://localhost:8378/1/sessions/me',
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
expect(typeof b.sessionToken).toEqual('string');
|
|
expect(typeof b.createdWith).toEqual('object');
|
|
expect(b.createdWith.action).toEqual('login');
|
|
expect(typeof b.user).toEqual('object');
|
|
expect(b.user.objectId).toEqual(user.id);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
it('user update session with other field', (done) => {
|
|
Parse.Promise.as().then(() => {
|
|
return Parse.User.signUp("finn", "human", { foo: "bar" });
|
|
}).then((user) => {
|
|
request.get({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken(),
|
|
'X-Parse-REST-API-Key': 'rest'
|
|
},
|
|
url: 'http://localhost:8378/1/sessions/me',
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
request.put({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken()
|
|
},
|
|
url: 'http://localhost:8378/1/sessions/' + b.objectId,
|
|
body: JSON.stringify({ foo: 'bar' })
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
it('get session only for current user', (done) => {
|
|
Parse.Promise.as().then(() => {
|
|
return Parse.User.signUp("test1", "test", { foo: "bar" });
|
|
}).then(() => {
|
|
return Parse.User.signUp("test2", "test", { foo: "bar" });
|
|
}).then((user) => {
|
|
request.get({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken(),
|
|
'X-Parse-REST-API-Key': 'rest'
|
|
},
|
|
url: 'http://localhost:8378/1/sessions'
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
expect(b.results.length).toEqual(1);
|
|
expect(typeof b.results[0].user).toEqual('object');
|
|
expect(b.results[0].user.objectId).toEqual(user.id);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
it('delete session by object', (done) => {
|
|
Parse.Promise.as().then(() => {
|
|
return Parse.User.signUp("test1", "test", { foo: "bar" });
|
|
}).then(() => {
|
|
return Parse.User.signUp("test2", "test", { foo: "bar" });
|
|
}).then((user) => {
|
|
request.get({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken(),
|
|
'X-Parse-REST-API-Key': 'rest'
|
|
},
|
|
url: 'http://localhost:8378/1/sessions'
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
expect(b.results.length).toEqual(1);
|
|
var objId = b.results[0].objectId;
|
|
request.del({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken(),
|
|
'X-Parse-REST-API-Key': 'rest'
|
|
},
|
|
url: 'http://localhost:8378/1/sessions/' + objId
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
request.get({
|
|
headers: {
|
|
'X-Parse-Application-Id': 'test',
|
|
'X-Parse-Session-Token': user.getSessionToken(),
|
|
'X-Parse-REST-API-Key': 'rest'
|
|
},
|
|
url: 'http://localhost:8378/1/sessions'
|
|
}, (error, response, body) => {
|
|
expect(error).toBe(null);
|
|
var b = JSON.parse(body);
|
|
expect(b.code).toEqual(209);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
it('password format matches hosted parse', (done) => {
|
|
var hashed = '$2a$10$8/wZJyEuiEaobBBqzTG.jeY.XSFJd0rzaN//ososvEI4yLqI.4aie';
|
|
crypto.compare('test', hashed)
|
|
.then((pass) => {
|
|
expect(pass).toBe(true);
|
|
done();
|
|
}, (e) => {
|
|
fail('Password format did not match.');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('changing password clears sessions', (done) => {
|
|
var sessionToken = null;
|
|
|
|
Parse.Promise.as().then(function() {
|
|
return Parse.User.signUp("fosco", "parse");
|
|
}).then(function(newUser) {
|
|
equal(Parse.User.current(), newUser);
|
|
sessionToken = newUser.getSessionToken();
|
|
ok(sessionToken);
|
|
newUser.set('password', 'facebook');
|
|
return newUser.save();
|
|
}).then(function() {
|
|
return Parse.User.become(sessionToken);
|
|
}).then(function(newUser) {
|
|
fail('Session should have been invalidated');
|
|
done();
|
|
}, function() {
|
|
done();
|
|
});
|
|
});
|
|
|
|
});
|
|
|