From 743060444557cdda43ec0c481f9e519c97f23988 Mon Sep 17 00:00:00 2001 From: Damon Wu Date: Fri, 17 Nov 2017 14:56:54 +1100 Subject: [PATCH] [ISDK-93] feature/auth-service-unit-test --- src/services/auth.service.spec.ts | 448 ++++++++++++++++++++++++++---- src/services/auth.service.ts | 23 +- 2 files changed, 415 insertions(+), 56 deletions(-) diff --git a/src/services/auth.service.spec.ts b/src/services/auth.service.spec.ts index 1042355a..a8e086d2 100644 --- a/src/services/auth.service.spec.ts +++ b/src/services/auth.service.spec.ts @@ -1,5 +1,5 @@ import {} from 'jasmine'; -import 'rxjs/Rx'; +import { Observable } from 'rxjs'; import { TestBed, getTestBed } from '@angular/core/testing'; import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing'; import { IonicStorageModule } from '@ionic/storage'; @@ -38,10 +38,215 @@ describe('AuthService', () => { service = injector.get(AuthService); httpMock = injector.get(HttpTestingController); }); + + // registration verification API returns + describe('verifyRegistration()', () => { + let registerVerifyTestCases = [ + // Case 1: lack of parameters without data return + { + returnUndefined: true, + params: { + email: null, + key: '12*35$1#' + }, + returnData: { + + }, + errorMsg: 'registration verification failed due to lack of parameters' + }, + // Case 2: full parameters with data return + { + returnUndefined: false, + params: { + email: 'test@test.com', + key: '3yg3fy4#' + }, + returnData: { + User: { + id: 123, + status: "registration" + } + }, + errorMsg: 'registration verification with API returns' + } + ]; + for (let index = 0; index < registerVerifyTestCases.length; index++) { + let registerVerifyTestCase = registerVerifyTestCases[index]; + it(registerVerifyTestCase.errorMsg, () => { + if (registerVerifyTestCase.returnUndefined) { + expect(service.verifyRegistration(registerVerifyTestCase.params)).toBeUndefined(); + } else { + let actualReturnedData = {}; + service.verifyRegistration(registerVerifyTestCase.params).subscribe(data => { + actualReturnedData = data; + }); + httpMock.expectOne('api/auths.json?action=verify_registration').flush(registerVerifyTestCase.returnData); + expect(actualReturnedData).toEqual(registerVerifyTestCase.returnData); + } + }); + } + }); + + // registration API returns + describe('register()', () => { + let registerTestCases = [ + // Case 1: registration failed due to lack of parameters + { + returnUndefined: true, + params: { + password: null, + user_id: 1, + key: null + }, + returnedData: { + + }, + errorMsg: 'registration failed due to lack of parameters' + }, + // Case 2: registration process with API returns + { + returnUndefined: false, + params: { + password: '6w7rg3aa2fhwe#wefwadwefwef', + user_id: 1, + key: '3yg3fy4#' + }, + returnedData: { + Program: { + id: 6, + experience_id: 3, + name: "Test Program", + max_achievable_points: 0 + }, + Timeline: { + id: 7, + title: "Test Timeline", + start_date: "2017-06-30", + state: 0 + }, + Project: { + id: 6, + name: "TEST Project", + description: "", + lead_image: null, + emails: "" + }, + Enrolment: { + id: 3600, + status: "fullaccess" + }, + apikey: "b335xxxaxa1dxxxf7b980e5" + }, + errorMsg: 'registration process with API returns' + } + ]; + for(let index = 0; index < registerTestCases.length; index++){ + let registerTestCase = registerTestCases[index]; + it(registerTestCase.errorMsg, () => { + if(registerTestCase.returnUndefined){ + expect(service.register(registerTestCase.params)).toBeUndefined(); + }else { + let actualReturns = {}; + service.register(registerTestCase.params).subscribe( + data => { + actualReturns = data; + } + ); + httpMock.expectOne('api/auths.json?action=registration').flush(registerTestCase.returnedData); + expect(actualReturns).toEqual(registerTestCase.returnedData); + } + }) + } + }); + + // login authentication API returns + describe('loginAuth()' , () => { + let loginTestCases = [ + // Case 1: login failed due to lack of parameters + { + returnUndefined: true, + params: { + email: null, + password: 'w467r32a3yg3fy4#dfghjsdfsd' + }, + returnedData: { + + }, + errorMsg: 'login failed due to lack of parameters' + }, + // Case 2: login process with API returns + { + returnUndefined: false, + params: { + email: 'test@test.com', + password: 'w467r32a3yg3fy4#dfghjsdfsd' + }, + returnedData: { + success: true, + tutorial: true, + apikey: '7xxxxxxxa3fdxxxx9330a6', + Timelines: [ + { + Timeline: { + id: 5, + title: 'test 1 2016S2', + start_date: '2016-10-23', + state: 1 + }, + Program: { + id: 4, + name: 'test 1', + max_achievable_points: 500 + }, + Project: { + id: 7, + name: 'test 1', + description: 'This is test project', + lead_image: null, + emails: '' + }, + Enrolment: { + id: 3, + status: 'fullaccess' + } + } + ], + Teams: [ + { + id: 1, + name: 'Team 1' + } + ], + Experience: { + config: {} + } + }, + errorMsg: 'login process with API returns' + } + ]; + for(let index = 0; index < loginTestCases.length; index++){ + let loginTestCase = loginTestCases[index]; + it(loginTestCase.errorMsg, () => { + if(loginTestCase.returnUndefined){ + expect(service.loginAuth(loginTestCase.params.email, loginTestCase.params.password)).toBeUndefined(); + }else { + let actualReturns = {}; + service.loginAuth(loginTestCase.params.email, loginTestCase.params.password).subscribe( + data => { + actualReturns = data; + } + ); + httpMock.expectOne('api/auths.json?action=authentication').flush(loginTestCase.returnedData); + expect(actualReturns).toEqual(loginTestCase.returnedData); + } + }) + } + }); + // get users API returns describe('getUser()' , () => { it('return user data', () => { - const fakeData = { + const userData = { email: 'test@test.com', experience_id: 3, image: null, @@ -53,69 +258,202 @@ describe('AuthService', () => { role: 'participant', timeline_id: 7 }; + let actualReturns = {}; service.getUser().subscribe(data => { - expect(data).toEqual(fakeData); + actualReturns = data; }); const req = httpMock.expectOne({ url: 'api/users.json', method: 'GET' }); - req.flush(fakeData); + req.flush(userData); + expect(actualReturns).toEqual(userData); }) }); - // login authentication API returns - describe('loginAuth()' , () => { - it('login successfully', () => { - const expectedLoggedInData = { - success: true, - tutorial: true, - apikey: '7xxxxxxxa3fdxxxx9330a6', - Timelines: [ - { - Timeline: { - id: 5, - title: 'test 1 2016S2', - start_date: '2016-10-23', - state: 1 - }, - Program: { - id: 4, - name: 'test 1', - max_achievable_points: 500 - }, - Project: { - id: 7, - name: 'test 1', - description: 'This is test project', - lead_image: null, - emails: '' - }, - Enrolment: { - id: 3559, - status: 'fullaccess' + + // forgot password API returns + describe('forgotPassword()', () => { + const forgotPasswordTestCases = [ + // Case 1: forgot password failed without email input + { + returnUndefined: true, + params: { + email: null + }, + returnedData: { + + }, + errorMsg: 'forgot password failed without email input' + }, + // Case 2: forgot password email has been sent out + { + returnUndefined: false, + params: { + email: 'test@test.com' + }, + returnedData: { + data: null + }, + errorMsg: 'forgot password email has been sent out' + } + ]; + for(let index = 0; index < forgotPasswordTestCases.length; index++){ + let forgotPasswordTestCase = forgotPasswordTestCases[index]; + it(forgotPasswordTestCase.errorMsg, () => { + if(forgotPasswordTestCase.returnUndefined){ + expect(service.forgotPassword(forgotPasswordTestCase.params.email)).toBeUndefined(); + }else { + let actualreturns = null; + service.forgotPassword(forgotPasswordTestCase.params).subscribe(data => { + actualreturns = data; + }) + httpMock.expectOne('api/auths.json?action=forgot_password').flush(forgotPasswordTestCase.returnedData); + expect(actualreturns).toEqual(forgotPasswordTestCase.returnedData); + } + }) + } + }); + + // // verify reset passoword API returns + describe('verifyUserKeyEmail()', () => { + const verifyResetPasswordTestCases = [ + // Case 1: verify reset password link failed due to lack of parameters + { + returnUndefined: true, + params: { + email: null, + key: '3yg3fy4#' + }, + returnedData: { + + }, + errorMsg: 'verify reset password link failed due to lack of parameters' + }, + // Case 2: verify reset password with API returns + { + returnUndefined: false, + params: { + email: 'test@test.com', + key: '3yg3fy4#' + }, + returnedData: { + data: null + }, + errorMsg: 'verify reset password with API returns' + } + ]; + for(let index = 0; index < verifyResetPasswordTestCases.length; index++){ + let verifyResetPasswordTestCase = verifyResetPasswordTestCases[index]; + it(verifyResetPasswordTestCase.errorMsg, () => { + if(verifyResetPasswordTestCase.returnUndefined){ + expect(service.verifyUserKeyEmail(verifyResetPasswordTestCase.params.key, verifyResetPasswordTestCase.params.email)).toBeUndefined(); + }else { + let actualReturns = {}; + service.verifyUserKeyEmail(verifyResetPasswordTestCase.params.key, verifyResetPasswordTestCase.params.email).subscribe( + data => { + actualReturns = data; } - } - ], - Teams: [ - { - id: 1, - name: 'Team 1' - } - ], - Experience: { - config: {} + ); + httpMock.expectOne('api/auths.json?action=verify_reset_password').flush(verifyResetPasswordTestCase.returnedData); + expect(actualReturns).toEqual(verifyResetPasswordTestCase.returnedData); } - }; - const userData = { - email: 'test@test.com', - password: 'w467r32a3yg3fy4#dfghjsdfsd' + }) + } + }); + + // reset passoword API returns + describe('resetUserPassword()', () => { + const resetPasswordTestCases = [ + // Case 1: reset password link failed due to lack of parameters + { + returnUndefined: true, + params: { + email: null, + password: null, + verify_password: null, + key: '3yg3fy4#' + }, + returnedData: { + + }, + errorMsg: 'reset password link failed due to lack of parameters' + }, + // Case 2: reset password with API returns + { + returnUndefined: false, + params: { + email: 'test@test.com', + password: '6w7rg3aa2fhwe#wefwadwefwef', + verify_password: '6w7rg3aa2fhwe#wefwadwefwef', + key: '3yg3fy4#' + }, + returnedData: { + data: null + }, + errorMsg: 'reset password with API returns' } - let actualLoggedInData = {}; - service.loginAuth(userData.email, userData.password).subscribe(data => { - actualLoggedInData = data; - }); - httpMock.expectOne('api/auths.json?action=authentication').flush(expectedLoggedInData); - expect(actualLoggedInData).toEqual(expectedLoggedInData); - }) + ]; + for(let index = 0; index < resetPasswordTestCases.length; index++){ + let resetPasswordTestCase = resetPasswordTestCases[index]; + it(resetPasswordTestCase.errorMsg, () => { + if(resetPasswordTestCase.returnUndefined){ + expect(service.resetUserPassword(resetPasswordTestCase.params.email, resetPasswordTestCase.params.key, resetPasswordTestCase.params.password, resetPasswordTestCase.params.verify_password)).toBeUndefined(); + }else { + let actualReturns = {}; + service.resetUserPassword(resetPasswordTestCase.params.email, resetPasswordTestCase.params.key, resetPasswordTestCase.params.password, resetPasswordTestCase.params.verify_password).subscribe( + data => { + actualReturns = data; + } + ); + httpMock.expectOne('api/auths.json?action=reset_password').flush(resetPasswordTestCase.returnedData); + expect(actualReturns).toEqual(resetPasswordTestCase.returnedData); + } + }) + } + }); + + // magic link login API returns + describe('magicLinkLogin()', () => { + const magicLinkTestCases = [ + // Case 1: magic link failed due to lack of parameters + { + returnUndefined: true, + params: { + auth_token: null, + }, + returnedData: { + + }, + errorMsg: 'magic link failed due to lack of parameters' + }, + // Case 2: magic link login with API returns + { + returnUndefined: false, + params: { + auth_token: '$2a$10$opa5v/CB3crj4Bdslm63475h34kjPcrkUmPedOA3SqyFhqHkE9YcCViw7ljp7m', + }, + returnedData: { + data: null + }, + errorMsg: 'magic link login with API returns' + } + ]; + for(let index = 0; index < magicLinkTestCases.length; index++){ + let magicLinkTestCase = magicLinkTestCases[index]; + it(magicLinkTestCase.errorMsg, () => { + if(magicLinkTestCase.returnUndefined){ + expect(service.magicLinkLogin(magicLinkTestCase.params.auth_token)).toBeUndefined(); + }else { + let actualReturns = {}; + service.magicLinkLogin(magicLinkTestCase.params).subscribe( + data => { + actualReturns = data; + } + ); + httpMock.expectOne('api/auths.json').flush(magicLinkTestCase.returnedData); + expect(actualReturns).toEqual(magicLinkTestCase.returnedData); + } + }) + } }); }) diff --git a/src/services/auth.service.ts b/src/services/auth.service.ts index c7997d4b..4d179a6e 100755 --- a/src/services/auth.service.ts +++ b/src/services/auth.service.ts @@ -15,10 +15,16 @@ export class AuthService { } verifyRegistration(data) { let email = data.email; - let key = data.key; + let key = data.key; + if(!data.email || !data.key){ + return undefined; + } return this.postRequest('verify_registration', { email, key }); } register(data) { + if(!data.password || !data.user_id || !data.key){ + return undefined; + } return this.postRequest('registration', { password: data.password, user_id: data.user_id, @@ -26,18 +32,33 @@ export class AuthService { }); } loginAuth(email, password) { + if(!email || !password){ + return undefined; + } return this.postRequest('authentication', `data[User][email]=${email}&data[User][password]=${password}`); } forgotPassword(email) { + if(!email){ + return undefined; + } return this.postRequest('forgot_password', { email }); } verifyUserKeyEmail(key, email) { + if(!key || !email){ + return undefined; + } return this.postRequest('verify_reset_password', { key, email }); } resetUserPassword(key, email, password, verify_password) { + if(!key || !email || !password || !verify_password){ + return undefined; + } return this.postRequest('reset_password', { key, email, password, verify_password }); } magicLinkLogin(auth_token) { + if(!auth_token){ + return undefined; + } return this.request.post('api/auths.json', { auth_token }); } getUser() {