xing-framework 0.0.1 → 0.0.2

data/default_configuration/base_app/frontend/test/auth/passwords/passwordsControllers.js

@@ -0,0 +1,193 @@
+import {appName} from 'config';
+import {} from '../../../src/app/auth/passwords/passwords.js';
+
+describe( 'Passwords controllers', function() {
+
+  beforeEach( module( `${appName}.auth.passwords` ) );
+
+  var $scope, $stateMock, $authMock, $toastMock, mockSerializer, mockLocation;
+
+  beforeEach(inject(function($q) {
+    $toastMock = {};
+    $toastMock.errorList = jasmine.createSpy('errorList');
+
+    $stateMock = jasmine.createSpyObj('$state', ["go", "href"]);
+
+    mockSerializer = function() {
+      this.serialize = function(data) {
+        return data;
+      };
+    };
+
+    // Lest anyone see this and think to imitate: don't.
+    // What should be happening is that we check that the authMock receives
+    // calls to requestPasswordReset with certain arguments, possibly returning
+    // certain values - *not* building a little mini $auth service in the test.
+    $authMock = {
+      requestPasswordReset(password_request) {
+        if (password_request.user.email) {
+          return $q((resolve, reject) => {
+            resolve();
+          });
+        } else {
+          return $q((resolve, reject) => {
+            reject({
+              data: {
+                errors: ["Missing Email"]
+              }
+            });
+          });
+        }
+      },
+      updatePassword(password_update) {
+        if (password_update.user.password &&
+            (password_update.user.password == password_update.user.passwordConfirmation)) {
+          return $q((resolve, reject) => {
+            resolve();
+          });
+        } else {
+          return $q((resolve, reject) => {
+            reject({
+              data: {
+                errors: { passwordConfirmation: "must match password" }
+              }
+            });
+          });
+        }
+      }
+    };
+
+    // And just to be clear "and.callThrough()" is the code smell here.
+    spyOn($authMock, 'requestPasswordReset').and.callThrough();
+    spyOn($authMock, 'updatePassword').and.callThrough();
+  }));
+
+  describe("Passwords Request Controller", function() {
+    var theUpdateUrl;
+
+    beforeEach( inject(function($controller, $rootScope) {
+      theUpdateUrl = "the://update.url/for_passwords";
+      $scope = $rootScope.$new();
+      $controller('PasswordsRequestCtrl', {
+        $scope: $scope,
+        $state: $stateMock,
+        $auth: $authMock,
+        $lrdToast: $toastMock,
+        $location: mockLocation,
+        Serializer: mockSerializer
+      });
+      $scope.$apply();
+    }));
+
+    it('should assign password request', function(){
+      expect($scope.passwordRequest).toEqualData({
+        email: ""});
+    });
+
+    describe("passwordRequestSubmit", function() {
+      describe("with valid request", function() {
+        beforeEach(function() {
+          $stateMock.href.and.returnValue(theUpdateUrl);
+          $scope.passwordRequest = { email: "bob@bob.com" };
+          $scope.passwordRequestSubmit();
+          $scope.$apply();
+        });
+
+        it ("should call the auth service", function() {
+          expect($authMock.requestPasswordReset).toHaveBeenCalled();
+          expect($authMock.requestPasswordReset.calls.mostRecent().args[0].update_url).toEqual(theUpdateUrl);
+        });
+
+        it ("should redirect to the password request success page", function() {
+          expect($stateMock.go).toHaveBeenCalledWith("root.inner.passwordsRequestSuccess");
+        });
+      });
+
+      describe("with invalid request", function() {
+        beforeEach(function() {
+          $scope.passwordRequest = { email: ''};
+          $scope.passwordRequestSubmit();
+          $scope.$apply();
+        });
+
+        it ("should call the auth service", function() {
+          expect($authMock.requestPasswordReset).toHaveBeenCalled();
+        });
+
+        it ("should set the toast error message", function() {
+          expect($toastMock.errorList).toHaveBeenCalledWith(["Missing Email"]);
+        });
+      });
+    });
+  });
+
+  describe("Passwords Update Controller", function() {
+    var theToken;
+
+    beforeEach( inject(function($controller, $rootScope) {
+      theToken = "someCryptoThingOrWhat";
+      mockLocation = jasmine.createSpyObj('$location', ['search']);
+      mockLocation.search.and.returnValue({token: theToken});
+
+      $scope = $rootScope.$new();
+      $controller('PasswordsUpdateCtrl', {
+        $scope: $scope,
+        $state: $stateMock,
+        $auth: $authMock,
+        $lrdToast: $toastMock,
+        Serializer: mockSerializer,
+        $location: mockLocation
+      });
+      $scope.$apply();
+    }));
+
+    it('should assign password update', function(){
+      expect($scope.passwordUpdate).toEqualData({
+        password: "",
+        passwordConfirmation: ""
+      });
+    });
+
+    describe("passwordUpdateSubmit", function() {
+      describe("with valid update", function() {
+        beforeEach(function() {
+          $scope.passwordUpdate = {
+            password: "jimbo",
+            passwordConfirmation: "jimbo"
+          };
+          $scope.passwordUpdateSubmit();
+          $scope.$apply();
+        });
+
+        it ("should call the auth service", function() {
+          expect($authMock.updatePassword).toHaveBeenCalled();
+          expect($authMock.updatePassword.calls.mostRecent().args[0].token).toEqual(theToken);
+        });
+
+        it ("should redirect to the passwords update success page", function() {
+          expect($stateMock.go).toHaveBeenCalledWith("root.inner.passwordsUpdateSuccess");
+        });
+      });
+
+      describe("with invalid request", function() {
+        beforeEach(function() {
+          $scope.passwordUpdate = {
+            password: "jimbo",
+            passwordConfirmation: "billyBob"
+          };
+          $scope.passwordUpdateSubmit();
+          $scope.$apply();
+        });
+
+        it ("should call the auth service", function() {
+          expect($authMock.updatePassword).toHaveBeenCalled();
+        });
+
+        it ("should set the toast error message", function() {
+          expect($toastMock.errorList).toHaveBeenCalledWith({ passwordConfirmation: "must match password" },
+          "We could not update your password because:");
+        });
+      });
+    });
+  });
+});

data/default_configuration/base_app/frontend/test/auth/passwords/passwordsStates.js

@@ -0,0 +1,108 @@
+import {appName} from 'config';
+import {} from '../../../src/app/auth/passwords/passwords.js';
+import {} from '../../support/testStates.js';
+import {LoggedInOnlyState} from "stateClasses";
+
+describe('Password Recovery states', function() {
+
+  var $rootScope, $state, $injector, state, $auth, $q;
+
+  beforeEach(function() {
+
+    module(`${appName}.testStates`);
+
+    module(`${appName}.auth.passwords`);
+
+    inject(function(_$rootScope_, _$state_, _$injector_, $templateCache, _$q_, _$auth_) {
+      $rootScope = _$rootScope_;
+      $state = _$state_;
+      $injector = _$injector_;
+      $q = _$q_;
+
+      $auth = _$auth_;
+
+      $templateCache.put('auth/passwords/passwords-request.tpl.html', '');
+      $templateCache.put('auth/passwords/passwords-request-success.tpl.html', '');
+      $templateCache.put('auth/passwords/passwords-update.tpl.html', '');
+      $templateCache.put('auth/passwords/passwords-update-success.tpl.html', '');
+    });
+  });
+
+  describe("passwordsRequest", function() {
+
+    beforeEach(function() {
+      state = $state.get('root.inner.passwordsRequest');
+    });
+
+    it('should respond to URL', function() {
+      expect($state.href(state)).toEqual('#/reset-password');
+    });
+
+    it('should render the passwords request template', function() {
+      expect(state.templateUrl).toEqual('auth/passwords/passwords-request.tpl.html');
+    });
+
+    it('should use the passwords request controller', function() {
+      expect(state.controller).toEqual('PasswordsRequestCtrl');
+    });
+
+  });
+
+  describe("passwordsRequestSuccess", function() {
+
+    beforeEach(function() {
+      state = $state.get('root.inner.passwordsRequestSuccess');
+    });
+
+    it('should respond to URL', function() {
+      expect($state.href(state)).toEqual('#/reset-password-sent');
+    });
+
+    it('should render the passwords request template', function() {
+      expect(state.templateUrl).toEqual('auth/passwords/passwords-request-success.tpl.html');
+    });
+
+  });
+
+  describe("passwordsUpdate", function() {
+
+    beforeEach(function() {
+      state = $state.get('root.inner.passwordsUpdate');
+    });
+
+    it('should extend LoggedInOnlyState', function() {
+      expect(state instanceof LoggedInOnlyState).toBe(true);
+    });
+
+    it('should respond to URL', function() {
+      expect($state.href(state)).toEqual('#/update-password');
+    });
+
+    it('should render the passwords update template', function() {
+      expect(state.templateUrl).toEqual('auth/passwords/passwords-update.tpl.html');
+    });
+
+    it('should use the passwords request controller', function() {
+      expect(state.controller).toEqual('PasswordsUpdateCtrl');
+    });
+  });
+
+  describe("passwordsUpdateSuccess", function() {
+
+    beforeEach(function() {
+      state = $state.get('root.inner.passwordsUpdateSuccess');
+    });
+
+    it('should extend LoggedInOnlyState', function() {
+      expect(state instanceof LoggedInOnlyState).toBe(true);
+    });
+
+    it('should respond to URL', function() {
+      expect($state.href(state)).toEqual('#/updated-password');
+    });
+
+    it('should render the sessions template', function() {
+      expect(state.templateUrl).toEqual('auth/passwords/passwords-update-success.tpl.html');
+    });
+  });
+});

data/default_configuration/base_app/frontend/test/auth/registrations/registrationsControllers.js

@@ -0,0 +1,117 @@
+import {appName} from '../../../src/common/config.js';
+import {} from '../../../src/app/auth/registrations/registrations.js';
+
+describe( 'Registrations controllers', function() {
+
+  beforeEach( module( `${appName}.auth.registrations` ) );
+
+  var $scope, $stateMock, $authMock, $toastMock, mockSerializer;
+
+  beforeEach(inject(function($q) {
+    $toastMock = {};
+    $toastMock.errorList = jasmine.createSpy('errorList');
+
+    $stateMock = {
+      go(state){}
+    };
+
+    mockSerializer = function() {
+      this.serialize = function(data) {
+        return data;
+      };
+    };
+
+    spyOn($stateMock, 'go').and.callThrough();
+
+    $authMock = {
+      submitRegistration(registration) {
+        if (registration.user.email &&
+            (registration.user.email == registration.user.emailConfirmation) &&
+            registration.user.password &&
+            (registration.user.password == registration.user.passwordConfirmation)) {
+          return $q((resolve, reject) => {
+            resolve();
+          });
+        } else {
+          return $q((resolve, reject) => {
+            reject({
+              data: {
+                errors: { emailConfirmation: "must match email" }
+              }
+            });
+          });
+        }
+      }
+    };
+
+    spyOn($authMock, 'submitRegistration').and.callThrough();
+
+  }));
+
+  describe("Registrations Controller", function() {
+
+    beforeEach( inject(function($controller, $rootScope) {
+      $scope = $rootScope.$new();
+      $controller('RegistrationsCtrl', {
+        $scope: $scope,
+        $state: $stateMock,
+        $auth: $authMock,
+        $lrdToast: $toastMock,
+        Serializer: mockSerializer
+      });
+      $scope.$apply();
+    }));
+
+    it('should assign session', function(){
+      expect($scope.registration).toEqualData({
+        email: "",
+        emailConfirmation: "",
+        password: "",
+        passwordConfirmation: ""});
+    });
+
+    describe("registrationSubmit", function() {
+      describe("with valid sign up", function() {
+        beforeEach(function() {
+          $scope.registration = { email: "bob@bob.com",
+            emailConfirmation: "bob@bob.com",
+            password: "password",
+            passwordConfirmation: "password"
+          };
+          $scope.registrationSubmit();
+          $scope.$apply();
+        });
+
+        it ("should call the auth service", function() {
+          expect($authMock.submitRegistration).toHaveBeenCalled();
+        });
+
+        it ("should redirect to the sign in success page", function() {
+          expect($stateMock.go).toHaveBeenCalledWith("root.inner.registrationsSuccess");
+        });
+
+      });
+
+      describe("with invalid login", function() {
+        beforeEach(function() {
+          $scope.registration = { email: "bob@bob.com",
+            emailConfirmation: "jill@jill.com",
+            password: "wrong password",
+            passwordConfirmation: "wrong password"
+          };
+          $scope.registrationSubmit();
+          $scope.$apply();
+        });
+
+        it ("should call the auth service", function() {
+          expect($authMock.submitRegistration).toHaveBeenCalled();
+        });
+
+        it ("should set the toast error message", function() {
+          expect($toastMock.errorList).toHaveBeenCalledWith({ emailConfirmation: "must match email" },
+            "We cannot process your registration because:");
+        });
+      });
+    });
+  });
+});

data/default_configuration/base_app/frontend/test/auth/registrations/registrationsStates.js

@@ -0,0 +1,64 @@
+import {appName} from 'config';
+import {} from '../../../src/app/auth/registrations/registrations.js';
+import {} from '../../support/testStates.js';
+
+describe('registrations states', function() {
+
+  var $rootScope, $state, $injector, state, $auth, $q;
+
+  beforeEach(function() {
+
+    module(`${appName}.testStates`);
+
+    module(`${appName}.auth.registrations`);
+
+    inject(function(_$rootScope_, _$state_, _$injector_, $templateCache, _$q_, _$auth_) {
+      $rootScope = _$rootScope_;
+      $state = _$state_;
+      $injector = _$injector_;
+      $q = _$q_;
+
+      $auth = _$auth_;
+
+      $templateCache.put('auth/registrations/registrations.tpl.html', '');
+      $templateCache.put('auth/registrations/registrations-success.tpl.html', '');
+    });
+  });
+
+  describe("registrations", function() {
+
+    beforeEach(function() {
+      state = $state.get('root.inner.registrations');
+    });
+
+    it('should respond to URL', function() {
+      expect($state.href(state)).toEqual('#/sign-up');
+    });
+
+    it('should render the sessions template', function() {
+      expect(state.templateUrl).toEqual('auth/registrations/registrations.tpl.html');
+    });
+
+    it('should use the sessions controller', function() {
+      expect(state.controller).toEqual('RegistrationsCtrl');
+    });
+
+  });
+
+  describe("registrationsSuccess", function() {
+
+    beforeEach(function() {
+      state = $state.get('root.inner.registrationsSuccess');
+    });
+
+    it('should respond to URL', function() {
+      expect($state.href(state)).toEqual('#/signed-up');
+    });
+
+    it('should render the sessions template', function() {
+      expect(state.templateUrl).toEqual('auth/registrations/registrations-success.tpl.html');
+    });
+
+  });
+
+});