mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-10-22 02:25:05 +00:00
1036 lines
31 KiB
JavaScript
1036 lines
31 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
* http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
"use strict";
|
|
|
|
var Cm = Components.manager;
|
|
|
|
Cu.import("resource://gre/modules/FxAccounts.jsm");
|
|
Cu.import("resource://gre/modules/FxAccountsCommon.js");
|
|
Cu.import("resource://gre/modules/FxAccountsManager.jsm");
|
|
Cu.import("resource://gre/modules/Promise.jsm");
|
|
Cu.import("resource://testing-common/MockRegistrar.jsm");
|
|
|
|
// === Mocks ===
|
|
|
|
// Globals representing server state
|
|
var passwordResetOnServer = false;
|
|
var deletedOnServer = false;
|
|
|
|
// Global representing FxAccounts state
|
|
var certExpired = false;
|
|
|
|
// Mock RP
|
|
function makePrincipal(origin, appId) {
|
|
let secMan = Cc["@mozilla.org/scriptsecuritymanager;1"]
|
|
.getService(Ci.nsIScriptSecurityManager);
|
|
let uri = Services.io.newURI(origin, null, null);
|
|
return secMan.createCodebasePrincipal(uri, {appId: appId});
|
|
}
|
|
var principal = makePrincipal('app://settings.gaiamobile.org', 27, false);
|
|
|
|
// For override FxAccountsUIGlue.
|
|
var fakeFxAccountsUIGlueCID;
|
|
|
|
// FxAccountsUIGlue fake component.
|
|
var FxAccountsUIGlue = {
|
|
_reject: false,
|
|
|
|
_error: 'error',
|
|
|
|
_signInFlowCalled: false,
|
|
|
|
_refreshAuthCalled: false,
|
|
|
|
_activeSession: null,
|
|
|
|
_reset: function() {
|
|
this._reject = false;
|
|
this._error = 'error';
|
|
this._signInFlowCalled = false;
|
|
this._refreshAuthCalled = false;
|
|
},
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIFxAccountsUIGlue]),
|
|
|
|
_promise: function() {
|
|
let deferred = Promise.defer();
|
|
|
|
if (this._reject) {
|
|
deferred.reject(this._error);
|
|
} else {
|
|
passwordResetOnServer = false;
|
|
FxAccountsManager._activeSession = this._activeSession || {
|
|
email: "user@domain.org",
|
|
verified: false,
|
|
sessionToken: "1234"
|
|
};
|
|
FxAccountsManager._fxAccounts
|
|
.setSignedInUser(FxAccountsManager._activeSession);
|
|
deferred.resolve(FxAccountsManager._activeSession);
|
|
}
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
signInFlow: function() {
|
|
deletedOnServer = false;
|
|
this._signInFlowCalled = true;
|
|
return this._promise();
|
|
},
|
|
|
|
refreshAuthentication: function() {
|
|
this._refreshAuthCalled = true;
|
|
return this._promise();
|
|
}
|
|
};
|
|
|
|
(function registerFakeFxAccountsUIGlue() {
|
|
fakeFxAccountsUIGlueCID =
|
|
MockRegistrar.register("@mozilla.org/fxaccounts/fxaccounts-ui-glue;1",
|
|
FxAccountsUIGlue);
|
|
})();
|
|
|
|
// Save original fxAccounts instance
|
|
const kFxAccounts = fxAccounts;
|
|
// and change it for a mock FxAccounts.
|
|
FxAccountsManager._fxAccounts = {
|
|
_reject: false,
|
|
_getSignedInUserCalled: false,
|
|
_setSignedInUserCalled: false,
|
|
|
|
_error: 'error',
|
|
_assertion: 'assertion',
|
|
_keys: 'keys',
|
|
_profile: 'aprofile',
|
|
_signedInUser: null,
|
|
|
|
_reset: function() {
|
|
this._getSignedInUserCalled = false;
|
|
this._setSignedInUserCalled = false;
|
|
this._reject = false;
|
|
},
|
|
|
|
accountStatus: function() {
|
|
let deferred = Promise.defer();
|
|
deferred.resolve(!deletedOnServer);
|
|
return deferred.promise;
|
|
},
|
|
|
|
getAssertion: function() {
|
|
if (!this._signedInUser) {
|
|
return null;
|
|
}
|
|
|
|
let deferred = Promise.defer();
|
|
if (passwordResetOnServer || deletedOnServer) {
|
|
deferred.reject({errno: ERRNO_INVALID_AUTH_TOKEN});
|
|
} else if (Services.io.offline && certExpired) {
|
|
deferred.reject(new Error(ERROR_OFFLINE));
|
|
} else {
|
|
deferred.resolve(this._assertion);
|
|
}
|
|
return deferred.promise;
|
|
},
|
|
|
|
getSignedInUser: function() {
|
|
this._getSignedInUserCalled = true;
|
|
let deferred = Promise.defer();
|
|
this._reject ? deferred.reject(this._error)
|
|
: deferred.resolve(this._signedInUser);
|
|
return deferred.promise;
|
|
},
|
|
|
|
getSignedInUserProfile: function() {
|
|
let deferred = Promise.defer();
|
|
this._reject ? deferred.reject(this._error)
|
|
: deferred.resolve(this._profile);
|
|
return deferred.promise;
|
|
},
|
|
|
|
getKeys: function() {
|
|
let deferred = Promise.defer();
|
|
this._reject ? deferred.reject(this._error)
|
|
: deferred.resolve(this._keys);
|
|
return deferred.promise;
|
|
},
|
|
|
|
resendVerificationEmail: function() {
|
|
return this.getSignedInUser().then(data => {
|
|
if (data) {
|
|
return Promise.resolve(true);
|
|
}
|
|
throw new Error("Cannot resend verification email; no signed-in user");
|
|
});
|
|
},
|
|
|
|
setSignedInUser: function(user) {
|
|
this._setSignedInUserCalled = true;
|
|
let deferred = Promise.defer();
|
|
this._signedInUser = user;
|
|
deferred.resolve();
|
|
return deferred.promise;
|
|
},
|
|
|
|
signOut: function() {
|
|
let deferred = Promise.defer();
|
|
this._signedInUser = null;
|
|
Services.obs.notifyObservers(null, ONLOGOUT_NOTIFICATION, null);
|
|
deferred.resolve();
|
|
return deferred.promise;
|
|
}
|
|
};
|
|
|
|
// Save original FxAccountsClient factory from FxAccountsManager.
|
|
const kFxAccountsClient = FxAccountsManager._getFxAccountsClient;
|
|
|
|
// and change it for a fake client factory.
|
|
var FakeFxAccountsClient = {
|
|
_reject: false,
|
|
_recoveryEmailStatusCalled: false,
|
|
_signInCalled: false,
|
|
_signUpCalled: false,
|
|
_signOutCalled: false,
|
|
|
|
_accountExists: false,
|
|
_verified: false,
|
|
_password: null,
|
|
|
|
_reset: function() {
|
|
this._reject = false;
|
|
this._recoveryEmailStatusCalled = false;
|
|
this._signInCalled = false;
|
|
this._signUpCalled = false;
|
|
this._signOutCalled = false;
|
|
},
|
|
|
|
recoveryEmailStatus: function() {
|
|
this._recoveryEmailStatusCalled = true;
|
|
let deferred = Promise.defer();
|
|
this._reject ? deferred.reject()
|
|
: deferred.resolve({ verified: this._verified });
|
|
return deferred.promise;
|
|
},
|
|
|
|
signIn: function(user, password, getKeys) {
|
|
this._signInCalled = true;
|
|
this._password = password;
|
|
this._keyFetchToken = getKeys ? "token" : null;
|
|
let deferred = Promise.defer();
|
|
this._reject ? deferred.reject()
|
|
: deferred.resolve({ email: user,
|
|
uid: "whatever",
|
|
verified: this._verified,
|
|
sessionToken: "1234" });
|
|
return deferred.promise;
|
|
},
|
|
|
|
signUp: function(user, password) {
|
|
this._signUpCalled = true;
|
|
return this.signIn(user, password);
|
|
},
|
|
|
|
signOut: function() {
|
|
this._signOutCalled = true;
|
|
let deferred = Promise.defer();
|
|
this._reject ? deferred.reject()
|
|
: deferred.resolve();
|
|
return deferred.promise;
|
|
},
|
|
|
|
accountExists: function() {
|
|
let deferred = Promise.defer();
|
|
this._reject ? deferred.reject()
|
|
: deferred.resolve(this._accountExists);
|
|
return deferred.promise;
|
|
}
|
|
};
|
|
|
|
FxAccountsManager._getFxAccountsClient = function() {
|
|
return FakeFxAccountsClient;
|
|
};
|
|
|
|
|
|
// === Global cleanup ===
|
|
|
|
// Unregister mocks and restore original code.
|
|
do_register_cleanup(function() {
|
|
// Unregister the factory so we do not leak
|
|
MockRegistrar.unregister(fakeFxAccountsUIGlueCID);
|
|
|
|
// Restore the original FxAccounts instance from FxAccountsManager.
|
|
FxAccountsManager._fxAccounts = kFxAccounts;
|
|
|
|
// Restore the FxAccountsClient getter from FxAccountsManager.
|
|
FxAccountsManager._getFxAccountsClient = kFxAccountsClient;
|
|
});
|
|
|
|
|
|
// === Tests ===
|
|
|
|
function run_test() {
|
|
run_next_test();
|
|
}
|
|
|
|
add_test(function test_initial_state() {
|
|
do_print("= Initial state =");
|
|
do_check_neq(FxAccountsManager, undefined);
|
|
do_check_null(FxAccountsManager._activeSession);
|
|
do_check_null(FxAccountsManager._user);
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function(test_getAccount_no_session) {
|
|
do_print("= getAccount no session =");
|
|
FxAccountsManager.getAccount().then(
|
|
result => {
|
|
do_check_null(result);
|
|
do_check_null(FxAccountsManager._activeSession);
|
|
do_check_null(FxAccountsManager._user);
|
|
do_check_true(FxAccountsManager._fxAccounts._getSignedInUserCalled);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_no_audience) {
|
|
do_print("= getAssertion no audience =");
|
|
FxAccountsManager.getAssertion().then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_INVALID_AUDIENCE);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_no_session_ui_error) {
|
|
do_print("= getAssertion no session, UI error =");
|
|
FxAccountsUIGlue._reject = true;
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_UI_ERROR);
|
|
do_check_eq(error.details, "error");
|
|
FxAccountsUIGlue._reset();
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_no_session_ui_success) {
|
|
do_print("= getAssertion no session, UI success =");
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_true(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_eq(error.error, ERROR_UNVERIFIED_ACCOUNT);
|
|
FxAccountsUIGlue._reset();
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_active_session_unverified_account) {
|
|
do_print("= getAssertion active session, unverified account =");
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
result => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_eq(error.error, ERROR_UNVERIFIED_ACCOUNT);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_active_session_verified_account) {
|
|
do_print("= getAssertion active session, verified account =");
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = true;
|
|
FxAccountsManager._activeSession.verified = true;
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
result => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_eq(result, "assertion");
|
|
FxAccountsManager._fxAccounts._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function() {
|
|
// getAssertion() succeeds if offline with valid cert
|
|
do_print("= getAssertion active session, valid cert, offline");
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = true;
|
|
FxAccountsManager._activeSession.verified = true;
|
|
Services.io.offline = true;
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
result => {
|
|
FxAccountsManager._fxAccounts._reset();
|
|
Services.io.offline = false;
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
Services.io.offline = false;
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function() {
|
|
// getAssertion() rejects if offline and cert expired.
|
|
do_print("= getAssertion active session, expired cert, offline");
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = true;
|
|
FxAccountsManager._activeSession.verified = true;
|
|
Services.io.offline = true;
|
|
certExpired = true;
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
result => {
|
|
Services.io.offline = false;
|
|
certExpired = false;
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_OFFLINE);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
Services.io.offline = false;
|
|
certExpired = false;
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function() {
|
|
// getAssertion() rejects if offline and UI needed.
|
|
do_print("= getAssertion active session, trigger UI, offline");
|
|
let user = FxAccountsManager._fxAccounts._signedInUser;
|
|
FxAccountsManager._fxAccounts._signedInUser = null;
|
|
Services.io.offline = true;
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
result => {
|
|
Services.io.offline = false;
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
FxAccountsManager._fxAccounts._signedInUser = user;
|
|
Services.io.offline = false;
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_refreshAuth) {
|
|
do_print("= getAssertion refreshAuth =");
|
|
let gracePeriod = 1200;
|
|
FxAccountsUIGlue._activeSession = {
|
|
email: "user@domain.org",
|
|
verified: true,
|
|
sessionToken: "1234"
|
|
};
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = true;
|
|
FxAccountsManager._activeSession.verified = true;
|
|
FxAccountsManager._activeSession.authAt =
|
|
(Date.now() / 1000) - gracePeriod;
|
|
FxAccountsManager.getAssertion("audience", principal, {
|
|
"refreshAuthentication": gracePeriod
|
|
}).then(
|
|
result => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_true(FxAccountsUIGlue._refreshAuthCalled);
|
|
do_check_eq(result, "assertion");
|
|
FxAccountsManager._fxAccounts._reset();
|
|
FxAccountsUIGlue._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_no_permissions) {
|
|
do_print("= getAssertion no permissions =");
|
|
|
|
let noPermissionsPrincipal = makePrincipal('app://dummy', 28);
|
|
let permMan = Cc["@mozilla.org/permissionmanager;1"]
|
|
.getService(Ci.nsIPermissionManager);
|
|
permMan.addFromPrincipal(noPermissionsPrincipal, FXACCOUNTS_PERMISSION,
|
|
Ci.nsIPermissionManager.DENY_ACTION);
|
|
|
|
FxAccountsUIGlue._activeSession = {
|
|
email: "user@domain.org",
|
|
verified: true,
|
|
sessionToken: "1234"
|
|
};
|
|
|
|
FxAccountsManager.getAssertion("audience", noPermissionsPrincipal).then(
|
|
result => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_false(FxAccountsUIGlue._refreshAuthCalled);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
FxAccountsUIGlue._reset();
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_permission_prompt_action) {
|
|
do_print("= getAssertion PROMPT_ACTION permission =");
|
|
|
|
let promptPermissionsPrincipal = makePrincipal('app://dummy-prompt', 29);
|
|
let permMan = Cc["@mozilla.org/permissionmanager;1"]
|
|
.getService(Ci.nsIPermissionManager);
|
|
permMan.addFromPrincipal(promptPermissionsPrincipal, FXACCOUNTS_PERMISSION,
|
|
Ci.nsIPermissionManager.PROMPT_ACTION);
|
|
|
|
FxAccountsUIGlue._activeSession = {
|
|
email: "user@domain.org",
|
|
verified: true,
|
|
sessionToken: "1234"
|
|
};
|
|
|
|
FxAccountsManager.getAssertion("audience", promptPermissionsPrincipal).then(
|
|
result => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_true(FxAccountsUIGlue._refreshAuthCalled);
|
|
do_check_eq(result, "assertion");
|
|
|
|
let permission = permMan.testPermissionFromPrincipal(
|
|
promptPermissionsPrincipal,
|
|
FXACCOUNTS_PERMISSION
|
|
);
|
|
do_check_eq(permission, Ci.nsIPermissionManager.ALLOW_ACTION);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
FxAccountsUIGlue._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_permission_prompt_action_refreshing) {
|
|
do_print("= getAssertion PROMPT_ACTION permission already refreshing =");
|
|
|
|
let promptPermissionsPrincipal = makePrincipal('app://dummy-prompt-2', 30);
|
|
let permMan = Cc["@mozilla.org/permissionmanager;1"]
|
|
.getService(Ci.nsIPermissionManager);
|
|
permMan.addFromPrincipal(promptPermissionsPrincipal, FXACCOUNTS_PERMISSION,
|
|
Ci.nsIPermissionManager.PROMPT_ACTION);
|
|
|
|
FxAccountsUIGlue._activeSession = {
|
|
email: "user@domain.org",
|
|
verified: true,
|
|
sessionToken: "1234"
|
|
};
|
|
|
|
FxAccountsManager._refreshing = true;
|
|
|
|
FxAccountsManager.getAssertion("audience", promptPermissionsPrincipal).then(
|
|
result => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_false(FxAccountsUIGlue._refreshAuthCalled);
|
|
do_check_null(result);
|
|
|
|
let permission = permMan.testPermissionFromPrincipal(
|
|
promptPermissionsPrincipal,
|
|
FXACCOUNTS_PERMISSION
|
|
);
|
|
do_check_eq(permission, Ci.nsIPermissionManager.PROMPT_ACTION);
|
|
|
|
FxAccountsManager._refreshing = false;
|
|
|
|
FxAccountsManager._fxAccounts._reset();
|
|
FxAccountsUIGlue._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_server_state_change) {
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = true;
|
|
FxAccountsManager._activeSession.verified = true;
|
|
passwordResetOnServer = true;
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
(result) => {
|
|
// For password reset, the UIGlue mock simulates sucessful
|
|
// refreshAuth which supplies new password, not signin/signup.
|
|
do_check_true(FxAccountsUIGlue._refreshAuthCalled);
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled)
|
|
do_check_eq(result, "assertion");
|
|
FxAccountsUIGlue._refreshAuthCalled = false;
|
|
}
|
|
).then(
|
|
() => {
|
|
deletedOnServer = true;
|
|
FxAccountsManager.getAssertion("audience", principal).then(
|
|
(result) => {
|
|
// For account deletion, the UIGlue's signin/signup is called.
|
|
do_check_true(FxAccountsUIGlue._signInFlowCalled)
|
|
do_check_false(FxAccountsUIGlue._refreshAuthCalled);
|
|
do_check_eq(result, "assertion");
|
|
deletedOnServer = false;
|
|
passwordResetOnServer = false;
|
|
FxAccountsUIGlue._reset()
|
|
run_next_test();
|
|
}
|
|
);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_refreshAuth_NaN) {
|
|
do_print("= getAssertion refreshAuth NaN=");
|
|
let gracePeriod = "NaN";
|
|
FxAccountsManager.getAssertion("audience", principal, {
|
|
"refreshAuthentication": gracePeriod
|
|
}).then(
|
|
result => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_false(FxAccountsUIGlue._refreshAuthCalled);
|
|
do_check_eq(error.error, ERROR_INVALID_REFRESH_AUTH_VALUE);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAssertion_refresh_auth_no_refresh) {
|
|
do_print("= getAssertion refreshAuth no refresh =");
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = true;
|
|
FxAccountsManager._activeSession.verified = true;
|
|
FxAccountsManager._activeSession.authAt =
|
|
(Date.now() / 1000) + 10000;
|
|
FxAccountsManager.getAssertion("audience", principal, {
|
|
"refreshAuthentication": 1
|
|
}).then(
|
|
result => {
|
|
do_check_false(FxAccountsUIGlue._signInFlowCalled);
|
|
do_check_eq(result, "assertion");
|
|
FxAccountsManager._fxAccounts._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAccount_existing_verified_session) {
|
|
do_print("= getAccount, existing verified session =");
|
|
FxAccountsManager._activeSession = null;
|
|
FxAccountsManager.getAccount().then(
|
|
result => {
|
|
do_check_true(FxAccountsManager._fxAccounts._getSignedInUserCalled);
|
|
do_check_eq(result.email, FxAccountsManager._user.email);
|
|
do_check_eq(result.verified, FxAccountsManager._user.verified);
|
|
do_check_eq(result.profile, "aprofile");
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAccount_existing_unverified_session_unverified_user) {
|
|
do_print("= getAccount, existing unverified session, unverified user =");
|
|
FxAccountsManager._activeSession.verified = false;
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = false;
|
|
FxAccountsManager.getAccount().then(
|
|
result => {
|
|
do_check_true(FakeFxAccountsClient._recoveryEmailStatusCalled);
|
|
do_check_false(result.verified);
|
|
do_check_eq(result.email, FxAccountsManager._user.email);
|
|
FakeFxAccountsClient._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getAccount_existing_unverified_session_verified_user) {
|
|
do_print("= getAccount, existing unverified session, verified user =");
|
|
FxAccountsManager._activeSession.verified = false;
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = false;
|
|
FakeFxAccountsClient._verified = true;
|
|
FxAccountsManager.getAccount();
|
|
do_execute_soon(function() {
|
|
do_check_true(FakeFxAccountsClient._recoveryEmailStatusCalled);
|
|
FxAccountsManager.getAccount().then(
|
|
result => {
|
|
do_check_true(result.verified);
|
|
do_check_eq(result.email, FxAccountsManager._user.email);
|
|
FakeFxAccountsClient._reset();
|
|
run_next_test();
|
|
});
|
|
});
|
|
});
|
|
|
|
add_test(function(test_signOut) {
|
|
do_print("= signOut =");
|
|
do_check_true(FxAccountsManager._activeSession != null);
|
|
FxAccountsManager.signOut().then(
|
|
result => {
|
|
do_check_null(result);
|
|
do_check_null(FxAccountsManager._activeSession);
|
|
do_check_true(FakeFxAccountsClient._signOutCalled);
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signUp_no_email) {
|
|
do_print("= signUp, no email=");
|
|
FxAccountsManager.signUp().then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_INVALID_EMAIL);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signIn_no_email) {
|
|
do_print("= signIn, no email=");
|
|
FxAccountsManager.signIn().then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_INVALID_EMAIL);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signUp_no_password) {
|
|
do_print("= signUp, no email=");
|
|
FxAccountsManager.signUp("user@domain.org").then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_INVALID_PASSWORD);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signIn_no_email) {
|
|
do_print("= signIn, no email=");
|
|
FxAccountsManager.signIn("user@domain.org").then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_INVALID_PASSWORD);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signUp) {
|
|
do_print("= signUp =");
|
|
FakeFxAccountsClient._verified = false;
|
|
FxAccountsManager.signUp("user@domain.org", "password").then(
|
|
result => {
|
|
do_check_true(FakeFxAccountsClient._signInCalled);
|
|
do_check_true(FakeFxAccountsClient._signUpCalled);
|
|
do_check_true(FxAccountsManager._fxAccounts._getSignedInUserCalled);
|
|
do_check_eq(FxAccountsManager._fxAccounts._signedInUser.email, "user@domain.org");
|
|
do_check_eq(FakeFxAccountsClient._password, "password");
|
|
do_check_true(result.accountCreated);
|
|
do_check_eq(result.user.email, "user@domain.org");
|
|
do_check_false(result.user.verified);
|
|
FakeFxAccountsClient._reset();
|
|
FxAccountsManager._fxAccounts._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error.error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signUp_already_signed_user) {
|
|
do_print("= signUp, already signed user =");
|
|
FxAccountsManager.signUp("user@domain.org", "password").then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_false(FakeFxAccountsClient._signInCalled);
|
|
do_check_eq(error.error, ERROR_ALREADY_SIGNED_IN_USER);
|
|
do_check_eq(error.details.user.email, "user@domain.org");
|
|
do_check_false(error.details.user.verified);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signIn_already_signed_user) {
|
|
do_print("= signIn, already signed user =");
|
|
FxAccountsManager.signIn("user@domain.org", "password").then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_ALREADY_SIGNED_IN_USER);
|
|
do_check_eq(error.details.user.email, "user@domain.org");
|
|
do_check_false(error.details.user.verified);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_signIn_getKeys_true) {
|
|
do_print("= signIn, getKeys true =");
|
|
FxAccountsManager.signOut().then(() => {
|
|
FxAccountsManager.signIn("user@domain.org", "password", true).then(
|
|
result => {
|
|
do_check_true(FakeFxAccountsClient._signInCalled);
|
|
do_check_true(FxAccountsManager._fxAccounts._getSignedInUserCalled);
|
|
do_check_eq(FxAccountsManager._fxAccounts._signedInUser.email, "user@domain.org");
|
|
do_check_eq(FakeFxAccountsClient._password, "password");
|
|
do_check_eq(FakeFxAccountsClient._keyFetchToken, "token");
|
|
do_check_eq(result.user.email, "user@domain.org");
|
|
FakeFxAccountsClient._reset();
|
|
FxAccountsManager._fxAccounts._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error");
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
add_test(function(test_signIn_getKeys_false) {
|
|
do_print("= signIn, getKeys false =");
|
|
FxAccountsManager.signOut().then(() => {
|
|
FxAccountsManager.signIn("user@domain.org", "password", false).then(
|
|
result => {
|
|
do_check_true(FakeFxAccountsClient._signInCalled);
|
|
do_check_true(FxAccountsManager._fxAccounts._getSignedInUserCalled);
|
|
do_check_eq(FxAccountsManager._fxAccounts._signedInUser.email, "user@domain.org");
|
|
do_check_eq(FakeFxAccountsClient._password, "password");
|
|
do_check_eq(FakeFxAccountsClient._keyFetchToken, null);
|
|
do_check_eq(result.user.email, "user@domain.org");
|
|
FakeFxAccountsClient._reset();
|
|
FxAccountsManager._fxAccounts._reset();
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error");
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
add_test(function(test_resendVerificationEmail_error_handling) {
|
|
do_print("= resendVerificationEmail smoke test =");
|
|
let user = FxAccountsManager._fxAccounts._signedInUser;
|
|
FxAccountsManager._fxAccounts._signedInUser.verified = false;
|
|
FxAccountsManager.resendVerificationEmail().then(
|
|
(success) => {
|
|
do_check_true(success);
|
|
},
|
|
(error) => {
|
|
do_throw("Unexpected failure");
|
|
}
|
|
);
|
|
// Here we verify that when FxAccounts.resendVerificationEmail
|
|
// throws an error, we gracefully handle it in the reject() channel.
|
|
FxAccountsManager._fxAccounts._signedInUser = null;
|
|
FxAccountsManager.resendVerificationEmail().then(
|
|
(success) => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
(error) => {
|
|
do_check_eq(error.error, ERROR_SERVER_ERROR);
|
|
}
|
|
);
|
|
FxAccountsManager._fxAccounts._signedInUser = user;
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function(test_verificationStatus_unverified_session_unverified_user) {
|
|
do_print("= verificationStatus unverified session and user =");
|
|
FakeFxAccountsClient._verified = false;
|
|
FxAccountsManager.verificationStatus();
|
|
do_execute_soon(function() {
|
|
let user = FxAccountsManager._user;
|
|
do_check_false(user.verified);
|
|
do_check_true(FakeFxAccountsClient._recoveryEmailStatusCalled);
|
|
do_check_false(FxAccountsManager._fxAccounts._setSignedInUserCalled);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
add_test(function(test_verificationStatus_unverified_session_verified_user) {
|
|
do_print("= verificationStatus unverified session, verified user =");
|
|
FakeFxAccountsClient._verified = true;
|
|
FxAccountsManager.verificationStatus();
|
|
do_execute_soon(function() {
|
|
let user = FxAccountsManager._user;
|
|
do_check_true(user.verified);
|
|
do_check_true(FakeFxAccountsClient._recoveryEmailStatusCalled);
|
|
do_check_true(FxAccountsManager._fxAccounts._setSignedInUserCalled);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
add_test(function(test_queryAccount_no_exists) {
|
|
do_print("= queryAccount, no exists =");
|
|
FxAccountsManager.queryAccount("user@domain.org").then(
|
|
result => {
|
|
do_check_false(result.registered);
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_queryAccount_exists) {
|
|
do_print("= queryAccount, exists =");
|
|
FakeFxAccountsClient._accountExists = true;
|
|
FxAccountsManager.queryAccount("user@domain.org").then(
|
|
result => {
|
|
do_check_true(result.registered);
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_queryAccount_no_email) {
|
|
do_print("= queryAccount, no email =");
|
|
FxAccountsManager.queryAccount().then(
|
|
() => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_INVALID_EMAIL);
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function() {
|
|
do_print("= fxaccounts:onlogout notification =");
|
|
do_check_true(FxAccountsManager._activeSession != null);
|
|
Services.obs.notifyObservers(null, ONLOGOUT_NOTIFICATION, null);
|
|
do_execute_soon(function() {
|
|
do_check_null(FxAccountsManager._activeSession);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
add_test(function(test_getKeys_sync_disabled) {
|
|
do_print("= getKeys sync disabled =");
|
|
Services.prefs.setBoolPref("services.sync.enabled", false);
|
|
FxAccountsManager.getKeys().then(
|
|
result => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error, ERROR_SYNC_DISABLED);
|
|
Services.prefs.clearUserPref("services.sync.enabled");
|
|
run_next_test();
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getKeys_no_session) {
|
|
do_print("= getKeys no session =");
|
|
Services.prefs.setBoolPref("services.sync.enabled", true);
|
|
FxAccountsManager._fxAccounts._signedInUser = null;
|
|
FxAccountsManager._activeSession = null;
|
|
FxAccountsManager.getKeys().then(
|
|
result => {
|
|
do_check_null(result);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
Services.prefs.clearUserPref("services.sync.enabled");
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error: " + error);
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getKeys_unverified_account) {
|
|
do_print("= getKeys unverified =");
|
|
Services.prefs.setBoolPref("services.sync.enabled", true);
|
|
FakeFxAccountsClient._verified = false;
|
|
FxAccountsManager.signIn("user@domain.org", "password").then(result => {
|
|
do_check_false(result.verified);
|
|
return FxAccountsManager.getKeys();
|
|
}).then(result => {
|
|
do_throw("Unexpected success");
|
|
},
|
|
error => {
|
|
do_check_eq(error.error, ERROR_UNVERIFIED_ACCOUNT);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
Services.prefs.clearUserPref("services.sync.enabled");
|
|
FxAccountsManager.signOut().then(run_next_test)
|
|
}
|
|
);
|
|
});
|
|
|
|
add_test(function(test_getKeys_success) {
|
|
do_print("= getKeys success =");
|
|
Services.prefs.setBoolPref("services.sync.enabled", true);
|
|
FakeFxAccountsClient._verified = true;
|
|
FxAccountsManager.signIn("user@domain.org", "password").then(result => {
|
|
return FxAccountsManager.getKeys();
|
|
}).then(result => {
|
|
do_check_eq(result, FxAccountsManager._fxAccounts._keys);
|
|
FxAccountsManager._fxAccounts._reset();
|
|
Services.prefs.clearUserPref("services.sync.enabled");
|
|
run_next_test();
|
|
},
|
|
error => {
|
|
do_throw("Unexpected error " + error);
|
|
}
|
|
);
|
|
});
|