works - but not quite what i want. Exposing jqXHR to error function

4 files changed, 45 insertions, 27 deletions

diff --git a/spec/helper.js b/spec/helper.js
index 11327af..8bae2c6 100644
--- a/spec/helper.js
+++ b/spec/helper.js
@@ -30,11 +30,11 @@ var specHelper = (function() {
     request.respond(200, header, body);
   }
 
-  function respondJSON(object) {
+  function respondJSON(object, responseCode) {
     var request = this.requests.pop();
     header = { "Content-Type": "application/json;charset=utf-8" };
     body = JSON.stringify(object);
-    request.respond(200, header, body);
+    request.respond(responseCode || 200, header, body);
   }
 
   return {
diff --git a/spec/login_spec.js b/spec/login_spec.js
index 4df62a8..3c30d28 100644
--- a/spec/login_spec.js
+++ b/spec/login_spec.js
@@ -48,7 +48,7 @@ describe("Login", function() {
       expect(this.srp.session.key()).toBe(K);
     });
 
-    it("works with JSON responses", function(){
+    it("authenticates successfully", function(){
       var success = sinon.spy();
       this.srp.identify(success);
 
@@ -60,6 +60,20 @@ describe("Login", function() {
       expect(success).toHaveBeenCalled();
     });
     
+    it("reports errors during handshake", function(){
+      this.srp.error = sinon.spy();
+      var error = {login: "something went wrong on the server side"};
+      this.srp.identify();
+
+      this.expectRequest('sessions.json', 'login=' +login+ '&A=' +A, 'POST');
+      this.respondJSON(error, 422);
+      //this.expectNoMoreRequests();
+
+      expect(this.srp.error).toHaveBeenCalled;
+      var args = this.srp.error.args[0];
+      expect($.parseJSON(args[0].responseText)).toEqual(error);
+    });
+    
     it("rejects B = 0", function(){
       var success = sinon.spy();
       var error = sinon.spy();
@@ -69,7 +83,7 @@ describe("Login", function() {
       this.respondJSON({salt: salt, B: 0});
       // aborting if B=0
       expect(this.requests).toEqual([]);
-      expect(error).toHaveBeenCalled();
+      expect(error).toHaveBeenCalledWith("Server send random number 0 - could not login.");
       expect(success).not.toHaveBeenCalled();
     });
   });
diff --git a/src/jqueryRest.js b/src/jqueryRest.js
index 54a0908..a7928d5 100644
--- a/src/jqueryRest.js
+++ b/src/jqueryRest.js
@@ -1,31 +1,30 @@
 jqueryRest = function() {
 
   // we do not fetch the salt from the server
-  function register(session, callback)
+  function register(session)
   {
-    sendVerifier(session, callback);
+    return sendVerifier(session);
   }
 
-  function sendVerifier(session, callback) {
+  function sendVerifier(session) {
     var salt = session.getSalt();
-    $.post("users.json", { user:
+    return $.post("users.json", { user:
       { login: session.getI(),
         password_salt: salt,
-        password_verifier: session.getV(salt).toString(16)}
-    }, callback);
+        password_verifier: session.getV(salt).toString(16)
+      }
+    });
   }
 
-  function handshake(session, callback) {
-    $.post("sessions.json", { login: session.getI(),
-      A: session.getAstr()}, callback);
+  function handshake(session) {
+    return $.post("sessions.json", { login: session.getI(), A: session.getAstr()});
   }
 
-  function authenticate(session, success) {
-    $.ajax({
+  function authenticate(session) {
+    return $.ajax({
       url: "sessions/" + session.getI() + ".json",
       type: 'PUT',
       data: {client_auth: session.getM()},
-      success: success
     });
   }
 
diff --git a/src/srp.js b/src/srp.js
index 6d1e8c1..6a377ce 100644
--- a/src/srp.js
+++ b/src/srp.js
@@ -2,8 +2,6 @@ function SRP(remote, session)
 {
   var srp = this;
   session = session || new this.Session();
-  remote = remote || new this.Remote();
-  remote.onError = remote.onError || this.error;
   session.onError = session.onError || this.error;
   this.remote = remote;
   this.session = session;
@@ -12,7 +10,9 @@ function SRP(remote, session)
   this.identify = function(success, error)
   {
     store_callbacks(success, error);
-    remote.handshake(session, receive_salts);
+    remote.handshake(session)
+    .success(receive_salts)
+    .error(srp.error);
 
     // Receive login salts from the server, start calculations
     function receive_salts(response)
@@ -28,7 +28,9 @@ function SRP(remote, session)
       else 
       {
         session.calculations(response.salt, response.B);
-        remote.authenticate(session, confirm_authentication);
+        remote.authenticate(session)
+        .success(confirm_authentication)
+        .error(srp.error);
       }
     }
 
@@ -47,12 +49,15 @@ function SRP(remote, session)
   this.register = function(success, error)
   {
     store_callbacks(success, error);
-    remote.register(session, srp.registered_user);
+    remote.register(session)
+    .success(srp.registered_user)
+    .error(srp.error);
   };
 
   // The user has been registered successfully, now login
   this.registered_user = function(response)
   {
+    // TODO: This can go if response has an error code
     if(response.errors) {
       srp.error(response.errors)
     }
@@ -61,12 +66,6 @@ function SRP(remote, session)
     }
   };  
 
-  // Minimal error handling - set remote.onError to sth better to overwrite.
-  this.error = function(text)
-  {
-    alert(text);
-  };
-
   // This function is called when authentication is successful.
   // It's a dummy. Please hand the real thing to the call to identify.
   this.success = function()
@@ -74,6 +73,12 @@ function SRP(remote, session)
     alert("Login successful.");
   };
 
+  // Minimal error handling - set remote.onError to sth better to overwrite.
+  this.error = function(text)
+  {
+    alert(text);
+  };
+
   function store_callbacks(success, error) {
     if (typeof success == "function") {
       srp.success = success;