refactor(select-union): extract to separate component

src/_constants/__mock__/unions.ts

@@ -0,0 +1,6 @@
+import {UnionMap} from '../unions';
+
+export const unions: UnionMap = {
+  key1: {key: 'key1', name: 'name1', url: 'http://url1'},
+  key2: {key: 'key2', name: 'name2', url: 'http://url2'},
+};

src/_constants/unions.ts

@@ -0,0 +1,17 @@
+import {InjectionToken} from '@angular/core';
+
+export const unions: UnionMap = {
+  mydata: {key: 'mydata', name: 'My Data', url: 'https://mydata.webtree.org/applyToken'},
+  imprint: {key: 'imprint', name: 'Imprint', url: 'https://imprint.webtree.org/applyToken'},
+  unions: {key: 'unions', name: 'Unions', url: 'https://unions.webtree.org/!/applyToken'}
+};
+
+export interface Union {
+  key: string;
+  name: string;
+  url: string;
+}
+
+export type UnionMap = Record<string, Union>;
+
+export const UNIONS_TOKEN = new InjectionToken<UnionMap>('unions');

src/_helpers/login.guard.spec.ts

@@ -0,0 +1,73 @@
+import {TestBed} from '@angular/core/testing';
+import {LoginGuard} from './login.guard';
+
+import {TokenService} from '../_services/token.service';
+import {AuthenticationService} from '../_services/authentication.service';
+import {ActivatedRouteSnapshot} from '@angular/router';
+import {isObservable, of} from 'rxjs';
+
+jest.mock('../_services/token.service');
+jest.mock('../_services/authentication.service');
+
+describe('Login Guard', () => {
+  let loginGuard: LoginGuard;
+  let tokenService: jest.Mocked<TokenService>;
+  let authService: jest.Mocked<AuthenticationService>;
+
+  const routeStub = {} as ActivatedRouteSnapshot;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        LoginGuard,
+        TokenService,
+        AuthenticationService
+      ]
+    });
+    loginGuard = TestBed.get(LoginGuard);
+    tokenService = TestBed.get(TokenService);
+    authService = TestBed.get(AuthenticationService);
+  });
+
+  it('should allow if token is not exist', () => {
+    tokenService.tokenExists.mockImplementation(() => false);
+
+    expect(loginGuard.canActivate(routeStub)).toBe(true);
+  });
+
+  it('should allow if token is not valid', (done) => {
+    tokenService.tokenExists.mockImplementation(() => true);
+    tokenService.isTokenValid.mockImplementation(() => of(false));
+
+    const res = loginGuard.canActivate(routeStub);
+    expect(isObservable(res)).toBeTruthy();
+    // always true. Workaround for typescript instead of 'as Observable<boolean>'
+    if (isObservable(res)) {
+      res.subscribe(canActivate => {
+        expect(canActivate).toBeTruthy();
+        done();
+      });
+    }
+  });
+
+  it.each`
+    requiredRedirect  | canActivate
+    ${true}           | ${false}
+    ${false}          | ${true}
+  `('canActivate = $s if token is valid and requiredRedirect = $requiredRedirect',
+    ({requiredRedirect, canActivate}) => {
+      tokenService.tokenExists.mockImplementation(() => true);
+      tokenService.isTokenValid.mockImplementation(() => of(true));
+      authService.redirectToUnionIfNeeded.mockImplementation(() => requiredRedirect);
+
+      const res = loginGuard.canActivate(routeStub);
+      expect(isObservable(res)).toBeTruthy();
+      // always true. Workaround for typescript instead of 'as Observable<boolean>'
+      if (isObservable(res)) {
+        res.subscribe(canActivateRes => {
+          expect(canActivateRes).toBe(canActivate);
+        });
+      }
+    });
+
+});

src/_helpers/login.guard.ts

@@ -0,0 +1,31 @@
+import {Injectable} from '@angular/core';
+import {ActivatedRouteSnapshot, CanActivate} from '@angular/router';
+import {Observable} from 'rxjs';
+import {map} from 'rxjs/operators';
+import {AuthenticationService} from '../_services/authentication.service';
+import {TokenService} from '../_services/token.service';
+
+@Injectable({providedIn: 'root'})
+export class LoginGuard implements CanActivate {
+  constructor(
+    private tokenService: TokenService,
+    private authenticationService: AuthenticationService,
+  ) {
+  }
+
+  canActivate(route: ActivatedRouteSnapshot): Observable<boolean> | boolean {
+    if (!this.tokenService.tokenExists()) {
+      return true;
+    }
+
+    return this.tokenService.isTokenValid().pipe(
+      map(isValid => {
+        if (isValid && this.authenticationService.shouldRedirect(route.queryParamMap)) {
+          this.authenticationService.redirect(route.queryParamMap);
+          return true;
+        }
+        return true;
+      })
+    );
+  }
+}

src/_models/Login.ts

@@ -0,0 +1,3 @@
+interface Login {
+  token: string;
+}

src/_services/alert.service.ts

@@ -1,7 +1,7 @@
 import {Injectable} from '@angular/core';
 import {MatSnackBar} from '@angular/material';
 
-@Injectable()
+@Injectable({ providedIn: 'root'})
 export class AlertService {
 
   constructor(private snackBar: MatSnackBar) {

src/_services/authentication.service.spec.ts

@@ -1,46 +1,78 @@
 import {TestBed} from '@angular/core/testing';
-import {HttpClientTestingModule, HttpTestingController} from '@angular/common/http/testing';
+import {HttpClientTestingModule, HttpTestingController, TestRequest} from '@angular/common/http/testing';
+import {DOCUMENT} from '@angular/common';
 import {AuthenticationService} from './authentication.service';
-import {User} from '../_models';
+import {User} from '../_models/User';
+
 import {TokenService} from './token.service';
 import {environment} from '../environments/environment';
+import {AlertService} from './alert.service';
+import {UNIONS_TOKEN} from '../_constants/unions';
+import {unions as unionsStub} from '../_constants/__mock__/unions';
 
 jest.mock('./token.service');
 jest.mock('../environments/environment');
+jest.mock('./alert.service');
 
-describe('AuthenticationService', () => {
+const documentStub = {
+  location: {
+   set href(value) {
+   }
+  },
+};
 
+describe('AuthenticationService', () => {
   let authService: AuthenticationService;
   let httpMock: HttpTestingController;
   let tokenService: jest.Mocked<TokenService>;
+  let alertService: jest.Mocked<AlertService>;
+  const locationHrefSetterSpy = jest.spyOn(documentStub.location, 'href', 'set');
 
   beforeEach(() => {
+
     TestBed.configureTestingModule({
-      providers: [TokenService, AuthenticationService],
+      providers: [
+        AuthenticationService,
+        AlertService,
+        TokenService,
+        {provide: UNIONS_TOKEN, useValue: unionsStub},
+        {provide: DOCUMENT, useValue: documentStub},
+      ],
       imports: [HttpClientTestingModule]
     });
 
     httpMock = TestBed.get(HttpTestingController);
     authService = TestBed.get(AuthenticationService);
     tokenService = TestBed.get(TokenService);
-
+    alertService = TestBed.get(AlertService);
   });
 
-  it('#login should sent request with correct data', (done) => {
+  describe('#login', () => {
     const user: User = {username: 'testUser', password: 'testPassword'};
+    let req: TestRequest;
+    let responseBody;
+    beforeEach(() => {
+      responseBody = null;
+    });
 
-    authService.login(user).subscribe((res) => {
-      expect(res).toEqual('someResponse');
-      done();
+    it('should return token received from server', (done) => {
+      responseBody = {token: 'testToken'};
+      authService.login(user).subscribe((res) => {
+        expect(res).toEqual(responseBody.token);
+        done();
+      });
+      req.flush(responseBody);
     });
 
-    const req = httpMock.expectOne('http://localhost:9000/rest/token/new');
-    expect(req.request.method).toEqual('POST');
-    expect(req.request.body).toEqual(user);
-    req.flush('someResponse');
-    httpMock.verify();
+    afterEach(() => {
+      // expect(req.request.method).toEqual('POST');
+      // expect(req.request.body).toEqual(user);
+
+      httpMock.verify();
+    });
   });
 
+
   it('#logout should call tokenService.removeToken()', () => {
     authService.logout();
     expect(tokenService.removeToken).toHaveBeenCalled();
@@ -53,34 +85,34 @@ describe('AuthenticationService', () => {
       tokenService.tokenExists.mockImplementation(() => true);
       tokenService.getToken.mockImplementation(() => 'testToken');
 
-      authService.isAuthorized().then(value => {
-        expect(value).toBeTruthy();
-        done();
-      });
+      // authService.isAuthorized().then(value => {
+      //   expect(value).toBeTruthy();
+      //   done();
+      // });
       verifyHttpCall();
     });
 
     it('should return false then token does not exist', async (done) => {
-      authService.isAuthorized().then(value => {
-        expect(value).toBeFalsy();
-        done();
-      });
+      // authService.isAuthorized().then(value => {
+      //   expect(value).toBeFalsy();
+      //   done();
+      // });
 
     });
 
     it('should not call backend if token not exists', () => {
-      authService.isAuthorized().then();
+      // authService.isAuthorized().then();
       httpMock.expectNone(environment.backendUrl + 'checkToken');
     });
 
     it('should check if token is valid', done => {
       tokenService.tokenExists.mockImplementation(() => true);
       tokenService.getToken.mockImplementation(() => 'wrongToken');
 
-      authService.isAuthorized().then(value => {
-        expect(value).toBeFalsy();
-        done();
-      });
+      // authService.isAuthorized().then(value => {
+      //   expect(value).toBeFalsy();
+      //   done();
+      // });
       verifyHttpCall({status: 401, statusText: 'Unauthorized'});
     });
 
@@ -89,7 +121,7 @@ describe('AuthenticationService', () => {
       tokenService.tokenExists.mockImplementation(() => true);
       tokenService.getToken.mockImplementation(() => token);
 
-      authService.isAuthorized().then();
+      // authService.isAuthorized().then();
 
       const req = verifyHttpCall();
       expect(req.request.method).toEqual('POST');

src/_services/authentication.service.ts

@@ -1,39 +1,74 @@
-import {Injectable} from '@angular/core';
-import 'rxjs/add/operator/map';
+import {HttpClient, HttpErrorResponse} from '@angular/common/http';
+import {Inject, Injectable} from '@angular/core';
+import {Observable, throwError} from 'rxjs';
+import {catchError, map} from 'rxjs/operators';
 import {TokenService} from './token.service';
-import {HttpClient} from '@angular/common/http';
 import {environment} from '../environments/environment';
-import {User} from '../_models';
+import {User} from '../_models/User';
+import {ParamMap} from '@angular/router';
+import {Union, UnionMap, UNIONS_TOKEN} from '../_constants/unions';
+import {DOCUMENT} from '@angular/common';
 
-@Injectable()
+@Injectable({providedIn: 'root'})
 export class AuthenticationService {
   constructor(private http: HttpClient,
-              private tokenService: TokenService) {
+              private tokenService: TokenService,
+              @Inject(UNIONS_TOKEN) private unions: UnionMap,
+              @Inject(DOCUMENT) private document: Document,
+  ) {
   }
 
-  login(user: User) {
-    return this.http.post(environment.backendUrl + 'token/new', user, {responseType: 'text'});
+  login(user: User): Observable<Login | null> {
+    return this.http.post<{ token: string }>(environment.backendUrl + 'token/new', user)
+      .pipe(
+        map(res => {
+          if ('token' in res) {
+            return { token: res.token };
+          }
+          throw new Error(`Valid token is not returned. Got: ${res}`);
+        }),
+        catchError((error: Error | HttpErrorResponse) => {
+          if ('status' in error) {
+            if (error.status === 401) {
+              return throwError('Invalid username or password');
+            }
+            return throwError(error.message || error.error);
+          }
+          return throwError(error);
+        })
+      );
   }
 
   logout() {
     this.tokenService.removeToken();
   }
 
-  async isAuthorized(): Promise<boolean> {
-    if (!this.tokenService.tokenExists()) {
-      return Promise.resolve(this.tokenService.tokenExists());
-    }
+  shouldRedirect(queryParamMap: ParamMap): boolean {
+    const returnUnion = this.getReturnUnion(queryParamMap);
 
-    return this.http.post(environment.backendUrl + 'checkToken', this.tokenService.getToken())
-      .toPromise()
-      .then(() => {
+    if (typeof returnUnion === 'string') {
+      if (returnUnion in this.unions) {
         return true;
-      }).catch((err) => {
-        if (err.status !== 401) {
-          console.error(err);
-        }
-        this.tokenService.removeToken();
-        return false;
-      });
+      } else {
+        throw new Error(`Unknown union: ${returnUnion}`);
+      }
+    }
+
+    return false;
+  }
+
+  redirect(queryParamMap: ParamMap): void {
+    const returnUnion = this.getReturnUnion(queryParamMap);
+    this.redirectToUnion(this.unions[returnUnion]);
+  }
+
+  redirectToUnion({ url }: Union): void {
+    const token = this.tokenService.getToken();
+
+    this.document.location.href = `${url}#token=${token}`;
+  }
+
+  getReturnUnion(queryParamMap: ParamMap): string | null {
+    return queryParamMap.get('returnUnion');
   }
 }