1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
import { TestBed } from '@angular/core/testing';
import { HttpRequest } from '@angular/common/http';
import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
import { Router } from '@angular/router';
import { UserInfo, UserCredentials } from '../entities';
import {
createTokenUrl, validateTokenUrl, CreateTokenRequest,
CreateTokenResponse, ValidateTokenRequest, ValidateTokenResponse
} from './http-entities';
import { InternalUserService, UserLoginState } from './internal-user.service';
describe('InternalUserService', () => {
const mockUserCredentials: UserCredentials = {
username: 'user',
password: 'user'
};
beforeEach(() => TestBed.configureTestingModule({
imports: [HttpClientTestingModule],
providers: [{ provide: Router, useValue: null }]
}));
it('should be created', () => {
const service: InternalUserService = TestBed.get(InternalUserService);
expect(service).toBeTruthy();
});
it('should be nologin at first', () => {
const service: InternalUserService = TestBed.get(InternalUserService);
expect(service.currentUserInfo).toBe(null);
service.refreshAndGetUserState().subscribe(result => {
expect(result).toBe('nologin');
});
});
it('login should work well', () => {
const service: InternalUserService = TestBed.get(InternalUserService);
const mockUserInfo: UserInfo = {
username: 'user',
roles: ['user', 'other']
};
service.tryLogin(mockUserCredentials).subscribe(result => {
expect(result).toEqual(mockUserInfo);
});
const httpController = TestBed.get(HttpTestingController) as HttpTestingController;
httpController.expectOne((request: HttpRequest<CreateTokenRequest>) =>
request.url === createTokenUrl &&
request.body.username === 'user' &&
request.body.password === 'user').flush(<CreateTokenResponse>{
token: 'test-token',
userInfo: mockUserInfo
});
expect(service.currentUserInfo).toEqual(mockUserInfo);
httpController.verify();
});
describe('validateUserLoginState', () => {
let service: InternalUserService;
let httpController: HttpTestingController;
const mockUserInfo: UserInfo = {
username: 'user',
roles: ['user', 'other']
};
const mockToken = 'mock-token';
const tokenValidateRequestMatcher = (req: HttpRequest<ValidateTokenRequest>) => {
return req.url === validateTokenUrl && req.body.token === mockToken;
};
beforeEach(() => {
service = TestBed.get(InternalUserService);
httpController = TestBed.get(HttpTestingController);
service.tryLogin(mockUserCredentials).subscribe(); // subscribe to activate login
httpController.expectOne(createTokenUrl).flush(<CreateTokenResponse>{
token: mockToken,
userInfo: mockUserInfo
});
});
it('success should work well', () => {
service.refreshAndGetUserState().subscribe((result: UserLoginState) => {
expect(result).toEqual(<UserLoginState>'success');
});
httpController.expectOne(tokenValidateRequestMatcher).flush(<ValidateTokenResponse>{
isValid: true,
userInfo: mockUserInfo
});
httpController.verify();
});
it('invalid should work well', () => {
service.refreshAndGetUserState().subscribe((result: UserLoginState) => {
expect(result).toEqual(<UserLoginState>'invalidlogin');
});
httpController.expectOne(tokenValidateRequestMatcher).flush(<ValidateTokenResponse>{ isValid: false });
httpController.verify();
});
});
// TODO: test on error situations.
});
|
