Some more tests

src/Squidex/app-config/webpack.test.js

@@ -3,4 +3,12 @@ webpackMerge = require('webpack-merge'),
 commonConfig = require('./webpack.config.js'),
      helpers = require('./helpers');
 
-module.exports = webpackMerge(commonConfig, { });
+module.exports = webpackMerge(commonConfig, { 
+    /**
+     * Source map for Karma from the help of karma-sourcemap-loader & karma-webpack
+     *
+     * Do not change, leave as is or it wont work.
+     * See: https://github.com/webpack/karma-webpack#source-maps
+     */
+    devtool: 'inline-source-map',
+});

src/Squidex/app/shared/services/apps-store.service.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Squidex Headless CMS
+ * 
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
 import * as TypeMoq from 'typemoq';
 
 import { Observable } from 'rxjs';
@@ -138,7 +145,7 @@ describe('AppsStoreService', () => {
         appsService.verifyAll();
     });
 
-    it('should select app', () => {
+    it('should select app', (done) => {
         authService.setup(x => x.isAuthenticated)
             .returns(() => Observable.of(true))
             .verifiable(TypeMoq.Times.once());
@@ -149,14 +156,16 @@ describe('AppsStoreService', () => {
 
         const store = new AppsStoreService(authService.object, appsService.object);
 
-        let result: AppDto = null;
+        store.selectApp('name').then((isSelected) => {
+            expect(isSelected).toBeTruthy();
 
-        store.selectApp('name').subscribe(app => {
+            appsService.verifyAll();
-            result = app;
-        });
 
-        expect(result).toEqual(oldApps[0]);
+            done();
+        }, err => {
+            expect(err).toBeNull();
 
-        appsService.verifyAll();
+            done();
+        });
     });
 });

src/Squidex/app/shared/services/apps.service.spec.ts

@@ -0,0 +1,135 @@
+/*
+ * Squidex Headless CMS
+ * 
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
+import * as TypeMoq from 'typemoq';
+import * as Ng2Http from '@angular/http';
+
+import { Observable } from 'rxjs';
+
+import {
+    ApiUrlConfig,
+    DateTime,
+    AppCreateDto,
+    AppDto,
+    AppsService,
+    AuthService
+} from './../';
+
+describe('AppsService', () => {
+    let authService: TypeMoq.Mock<AuthService>;
+    let appsService: AppsService;
+
+    beforeEach(() => {
+        authService = TypeMoq.Mock.ofType(AuthService);
+        appsService = new AppsService(authService.object, new ApiUrlConfig('http://service/p/'));
+    });
+
+    it('should make get request with auth service', () => {
+        authService.setup(x => x.authGet('http://service/p/api/apps'))
+            .returns(() => Observable.of(
+                new Ng2Http.Response(
+                    new Ng2Http.ResponseOptions({
+                        body: [{
+                            id: '123',
+                            name: 'name1',
+                            created: '2016-01-01',
+                            lastModified: '2017-01-01'
+                        }, {
+                            id: '456',
+                            name: 'name2',
+                            created: '2016-01-01',
+                            lastModified: '2017-01-01'
+                        }]
+                    })
+                )
+            ))
+            .verifiable(TypeMoq.Times.once());
+
+        let apps: AppDto[] = null;
+        
+        appsService.getApps().subscribe(result => {
+            apps = result;
+        }).unsubscribe();
+
+        expect(apps[1].id).toBe('456');
+        expect(apps[1].name).toBe('name2');
+        expect(apps[1].created.eq(DateTime.parseISO('2016-01-01'))).toBeTruthy();
+        expect(apps[1].lastModified.eq(DateTime.parseISO('2017-01-01'))).toBeTruthy();
+
+        authService.verifyAll();
+    });
+
+    it('should make post request', () => {
+        const now = DateTime.now();
+
+        authService.setup(x => x.authPost('http://service/p/api/apps', TypeMoq.It.is(y => y['name'] === 'new-app')))
+            .returns(() => Observable.of(
+               new Ng2Http.Response(
+                    new Ng2Http.ResponseOptions({
+                        body: {
+                            id: '123'
+                        }
+                    })
+                )
+            ));
+
+        let newApp: AppDto = null;
+
+        appsService.postApp(new AppCreateDto('new-app'), now).subscribe(result => {
+            newApp = result;
+        }).unsubscribe();
+
+        expect(newApp.id).toBe('123');
+        expect(newApp.name).toBe('new-app');
+        expect(newApp.created.eq(now)).toBeTruthy();
+        expect(newApp.lastModified.eq(now)).toBeTruthy();
+
+        authService.verifyAll();
+    });
+
+    it('should throw fallback error on 500', () => {
+        authService.setup(x => x.authPost('http://service/p/api/apps', TypeMoq.It.isAny()))
+            .returns(() => Observable.throw(
+                new Ng2Http.Response(
+                    new Ng2Http.ResponseOptions({
+                        status: 500
+                    })
+                )
+            ));
+
+        let error = '';
+
+        appsService.postApp(new AppCreateDto('new-app')).subscribe(x => {}, result => {
+            error = result;
+        }).unsubscribe();
+
+        expect(error).toBe('A new app could not be created.');
+
+        authService.verifyAll();
+    });
+
+    it('should throw duplicate error on 400', () => {
+        authService.setup(x => x.authPost('http://service/p/api/apps', TypeMoq.It.isAny()))
+            .returns(() => Observable.throw(
+                new Ng2Http.Response(
+                    new Ng2Http.ResponseOptions({
+                        status: 400
+                    })
+                )
+            ));
+
+        let error = '';
+
+        appsService.postApp(new AppCreateDto('new-app')).subscribe(x => {}, result => {
+            error = result;
+        }).unsubscribe();
+
+        expect(error).toBe('An app with the same name already exists.');
+
+        authService.verifyAll();
+    });
+});

src/Squidex/app/shared/services/apps.service.ts

@@ -54,18 +54,18 @@ export class AppsService {
                 });
     }
 
-    public postApp(appToCreate: AppCreateDto): Observable<AppDto> {
+    public postApp(appToCreate: AppCreateDto, now?: DateTime): Observable<AppDto> {
-        const now = DateTime.now();
+        now = now || DateTime.now();
 
         return this.authService.authPost(this.apiUrl.buildUrl('api/apps'), appToCreate)
+                .map(response => response.json())
+                .map(response => new AppDto(response.id, appToCreate.name, now, now))
                 .catch(response => {
                     if (response.status === 400) {
                         return Observable.throw('An app with the same name already exists.');
                     } else {
                         return Observable.throw('A new app could not be created.');
                     }
-                })
+                });
-                .map(response => response.json())
-                .map(response => new AppDto(response.id, appToCreate.name, now, now));
     }
 }

src/Squidex/app/shared/services/auth.service.ts

@@ -59,31 +59,33 @@ export class AuthService {
         private readonly http: Ng2Http.Http,
         private readonly router: Ng2Router.Router,
     ) {
+        if (!apiUrl) {
+            return;
+        }
+
         Log.logger = console;
 
-        if (apiUrl) {
+        this.userManager = new UserManager({
-            this.userManager = new UserManager({
+                       client_id: 'squidex-frontend',
-                           client_id: 'squidex-frontend',
+                           scope: 'squidex-api openid profile squidex-profile',
-                               scope: 'squidex-api openid profile squidex-profile',
+                   response_type: 'id_token token',
-                       response_type: 'id_token token',
+                    redirect_uri: apiUrl.buildUrl('login;'),
-                        redirect_uri: apiUrl.buildUrl('login;'),
+        post_logout_redirect_uri: apiUrl.buildUrl('logout'),
-            post_logout_redirect_uri: apiUrl.buildUrl('logout'),
+             silent_redirect_uri: apiUrl.buildUrl('identity-server/client-callback-silent/'),
-                 silent_redirect_uri: apiUrl.buildUrl('identity-server/client-callback-silent/'),
+              popup_redirect_uri: apiUrl.buildUrl('identity-server/client-callback-popup/'),
-                  popup_redirect_uri: apiUrl.buildUrl('identity-server/client-callback-popup/'),
+                       authority: apiUrl.buildUrl('identity-server/'),
-                           authority: apiUrl.buildUrl('identity-server/'),
+            automaticSilentRenew: true
-                automaticSilentRenew: true
+        });
-            });
+
-
+        this.userManager.events.addUserLoaded(user => {
-            this.userManager.events.addUserLoaded(user => {
+            this.onAuthenticated(user);
-                this.onAuthenticated(user);
+        });
-            });
+
-
+        this.userManager.events.addUserUnloaded(() => {
-            this.userManager.events.addUserUnloaded(() => {
+            this.onDeauthenticated();
-                this.onDeauthenticated();
+        });
-            });
+
-
+        this.checkLogin();
-            this.checkLogin();
-        }
 
         this.isAuthenticatedChangedPublished$.connect();
     }

src/Squidex/tslint.json

@@ -46,7 +46,7 @@
     "no-shadowed-variable": true,
     "no-string-literal": false,
     "no-switch-case-fall-through": true,
-    "no-trailing-whitespace": true,
+    "no-trailing-whitespace": false,
     "no-unreachable": true,
     "no-unused-expression": true,
     "no-unused-variable": true,