Asset service tests

src/Squidex/Controllers/Api/Assets/Models/AssetCreatedDto.cs

@@ -69,6 +69,7 @@ namespace Squidex.Controllers.Api.Assets.Models
                 Id = command.AssetId,
                 FileName = command.File.FileName,
                 FileSize = command.File.FileSize,
+                FileVersion = result.Version,
                 MimeType = command.File.MimeType,
                 IsImage = command.ImageInfo != null,
                 PixelWidth = command.ImageInfo?.PixelWidth,

src/Squidex/Controllers/Api/Assets/Models/AssetDto.cs

@@ -37,6 +37,11 @@ namespace Squidex.Controllers.Api.Assets.Models
         /// </summary>
         public long FileSize { get; set; }
 
+        /// <summary>
+        /// The version of the file.
+        /// </summary>
+        public long FileVersion { get; set; }
+
         /// <summary>
         /// Determines of the created file is an image.
         /// </summary>

src/Squidex/app/features/assets/pages/asset.component.ts

@@ -68,11 +68,11 @@ export class AssetComponent extends AppComponentBase implements OnInit {
     public progress = 0;
 
     public get previewUrl(): string {
-        return this.apiUrl.buildUrl(`api/assets/${this.asset.id}/?width=230&height=155&mode=Crop&version=${this.version.value}&q=${this.cacheBuster}`);
+        return this.apiUrl.buildUrl(`api/assets/${this.asset.id}?width=230&height=155&mode=Crop&version=${this.version.value}&q=${this.cacheBuster}`);
     }
 
     public get downloadUrl(): string {
-        return this.apiUrl.buildUrl(`api/assets/${this.asset.id}/?q=${this.cacheBuster}`);
+        return this.apiUrl.buildUrl(`api/assets/${this.asset.id}?q=${this.cacheBuster}`);
     }
 
     public get fileType(): string {
@@ -190,7 +190,7 @@ export class AssetComponent extends AppComponentBase implements OnInit {
             const dto = new UpdateAssetDto(this.renameForm.controls['name'].value);
 
             this.appName()
-                .switchMap(app => this.assetsService.updateAsset(app, this.asset.id, dto, this.version))
+                .switchMap(app => this.assetsService.putAsset(app, this.asset.id, dto, this.version))
                 .subscribe(_ => {
                     const me = `subject:${this.authService.user!.id}`;
 

src/Squidex/app/framework/utils/pager.spec.ts

@@ -8,6 +8,21 @@
 import { Pager } from './../';
 
 describe('Pager', () => {
+    it('Should init with default values', () => {
+        const pager_1 = new Pager(0);
+
+        expect(Object.assign({}, pager_1)).toEqual({
+            page: 0,
+            pageSize: 10,
+            itemFirst: 0,
+            itemLast: 0,
+            skip: 0,
+            numberOfItems: 0,
+            canGoNext: false,
+            canGoPrev: false
+        });
+    });
+
     it('Should init with page size and page', () => {
         const pager_1 = new Pager(23, 2, 10);
 

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

@@ -0,0 +1,278 @@
+/*
+ * Squidex Headless CMS
+ *
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
+import { Response, ResponseOptions } from '@angular/http';
+import { Observable } from 'rxjs';
+import { ProgressHttp } from 'angular-progress-http';
+import { IMock, It, Mock, Times } from 'typemoq';
+
+import {
+    ApiUrlConfig,
+    AssetsDto,
+    AssetDto,
+    AssetCreatedDto,
+    AssetReplacedDto,
+    AssetsService,
+    AuthService,
+    DateTime,
+    Profile,
+    UpdateAssetDto,
+    Version
+} from './../';
+
+describe('AssetsService', () => {
+    let authService: IMock<AuthService>;
+    let assetsService: AssetsService;
+    let progressHttp: IMock<ProgressHttp>;
+    let version = new Version('1');
+
+    beforeEach(() => {
+        const factory = {
+            create: () => {
+                return <any>null;
+            }
+        };
+
+        progressHttp = Mock.ofInstance(new ProgressHttp(null, null, factory, null));
+        progressHttp.setup(x => x.withUploadProgressListener(It.isAny())).returns(() => <any> progressHttp.object);
+
+        authService = Mock.ofType(AuthService);
+        authService.setup(x => x.user).returns(() => new Profile(<any>{}));
+
+        assetsService = new AssetsService(authService.object, new ApiUrlConfig('http://service/p/'), progressHttp.object);
+    });
+
+    it('should make get request to get assets', () => {
+        authService.setup(x => x.authGet('http://service/p/api/apps/my-app/assets?take=17&skip=13'))
+            .returns(() => Observable.of(
+                new Response(
+                    new ResponseOptions({
+                        body: {
+                            total: 10,
+                            items: [{
+                                id: 'id1',
+                                created: '2016-12-12T10:10',
+                                createdBy: 'Created1',
+                                lastModified: '2017-12-12T10:10',
+                                lastModifiedBy: 'LastModifiedBy1',
+                                fileName: 'my-asset1.png',
+                                fileSize: 1024,
+                                fileVersion: 2,
+                                mimeType: 'text/plain',
+                                isImage: true,
+                                pixelWidth: 1024,
+                                pixelHeight: 2048,
+                                version: 11
+                            }, {
+                                id: 'id2',
+                                created: '2016-10-12T10:10',
+                                createdBy: 'Created2',
+                                lastModified: '2017-10-12T10:10',
+                                lastModifiedBy: 'LastModifiedBy2',
+                                fileName: 'my-asset2.png',
+                                fileSize: 1024,
+                                fileVersion: 2,
+                                mimeType: 'text/plain',
+                                isImage: true,
+                                pixelWidth: 1024,
+                                pixelHeight: 2048,
+                                version: 22
+                            }]
+                        }
+                    })
+                )
+            ))
+            .verifiable(Times.once());
+
+        let assets: AssetsDto | null = null;
+
+        assetsService.getAssets('my-app', 17, 13, null, null).subscribe(result => {
+            assets = result;
+        }).unsubscribe();
+
+        expect(assets).toEqual(
+            new AssetsDto(10, [
+                new AssetDto(
+                    'id1', 'Created1', 'LastModifiedBy1',
+                    DateTime.parseISO_UTC('2016-12-12T10:10'),
+                    DateTime.parseISO_UTC('2017-12-12T10:10'),
+                    'my-asset1.png',
+                    1024, 2,
+                    'text/plain',
+                    true,
+                    1024,
+                    2048,
+                    new Version('11')),
+                new AssetDto('id2', 'Created2', 'LastModifiedBy2',
+                    DateTime.parseISO_UTC('2016-10-12T10:10'),
+                    DateTime.parseISO_UTC('2017-10-12T10:10'),
+                    'my-asset2.png',
+                    1024, 2,
+                    'text/plain',
+                    true,
+                    1024,
+                    2048,
+                    new Version('22'))
+        ]));
+
+        authService.verifyAll();
+    });
+
+    it('should append query to find by name', () => {
+        authService.setup(x => x.authGet('http://service/p/api/apps/my-app/assets?query=my-query&take=17&skip=13'))
+            .returns(() => Observable.of(
+                new Response(
+                    new ResponseOptions({
+                        body: {
+                            total: 10,
+                            items: []
+                        }
+                    })
+                )
+            ))
+            .verifiable(Times.once());
+
+        let assets: AssetsDto | null = null;
+
+        assetsService.getAssets('my-app', 17, 13, 'my-query', null).subscribe(result => {
+            assets = result;
+        }).unsubscribe();
+
+        authService.verifyAll();
+    });
+
+    it('should append mime types to find by types', () => {
+        authService.setup(x => x.authGet('http://service/p/api/apps/my-app/assets?mimeTypes=text/plain,image/png&take=17&skip=13'))
+            .returns(() => Observable.of(
+                new Response(
+                    new ResponseOptions({
+                        body: {
+                            total: 10,
+                            items: []
+                        }
+                    })
+                )
+            ))
+            .verifiable(Times.once());
+
+        let assets: AssetsDto | null = null;
+
+        assetsService.getAssets('my-app', 17, 13, null, ['text/plain', 'image/png']).subscribe(result => {
+            assets = result;
+        }).unsubscribe();
+
+        authService.verifyAll();
+    });
+
+    it('should make post request to create asset', () => {
+        progressHttp.setup(x => x.post('http://service/p/api/apps/my-app/assets', It.isAny(), It.isAny()))
+            .returns(() => Observable.of(
+               new Response(
+                    new ResponseOptions({
+                        body: {
+                            id: 'id1',
+                            fileName: 'my-asset1.png',
+                            fileSize: 1024,
+                            fileVersion: 2,
+                            mimeType: 'text/plain',
+                            isImage: true,
+                            pixelWidth: 1024,
+                            pixelHeight: 2048,
+                            version: 11
+                        }
+                    })
+                )
+            ))
+            .verifiable(Times.once());
+
+        let asset: AssetCreatedDto | null = null;
+
+        assetsService.uploadFile('my-app', null).subscribe(result => {
+            asset = <AssetCreatedDto>result;
+        });
+
+        expect(asset).toEqual(
+            new AssetCreatedDto(
+                'id1',
+                'my-asset1.png',
+                1024, 2,
+                'text/plain',
+                true,
+                1024,
+                2048,
+                new Version('11')));
+
+        authService.verifyAll();
+    });
+
+    it('should make put request to replace asset content', () => {
+        progressHttp.setup(x => x.put('http://service/p/api/apps/my-app/assets/123/content', It.isAny(), It.isAny()))
+            .returns(() => Observable.of(
+               new Response(
+                    new ResponseOptions({
+                        body: {
+                            fileSize: 1024,
+                            fileVersion: 2,
+                            mimeType: 'text/plain',
+                            isImage: true,
+                            pixelWidth: 1024,
+                            pixelHeight: 2048,
+                            version: 11
+                        }
+                    })
+                )
+            ))
+            .verifiable(Times.once());
+
+        let asset: AssetReplacedDto | null = null;
+
+        assetsService.replaceFile('my-app', '123', null, version).subscribe(result => {
+            asset = <AssetReplacedDto>result;
+        });
+
+        expect(asset).toEqual(
+            new AssetReplacedDto(
+                1024, 2,
+                'text/plain',
+                true,
+                1024,
+                2048,
+                new Version('11')));
+
+        authService.verifyAll();
+    });
+
+    it('should make put request to update asset', () => {
+        const dto = new UpdateAssetDto('My-Asset.pdf');
+
+        authService.setup(x => x.authPut('http://service/p/api/apps/my-app/assets/123', dto, version))
+            .returns(() => Observable.of(
+               new Response(
+                    new ResponseOptions()
+                )
+            ))
+            .verifiable(Times.once());
+
+        assetsService.putAsset('my-app', '123', dto, version);
+
+        authService.verifyAll();
+    });
+
+    it('should make delete request to delete asset', () => {
+        authService.setup(x => x.authDelete('http://service/p/api/apps/my-app/assets/123', version))
+            .returns(() => Observable.of(
+               new Response(
+                    new ResponseOptions()
+                )
+            ))
+            .verifiable(Times.once());
+
+        assetsService.deleteAsset('my-app', '123', version);
+
+        authService.verifyAll();
+    });
+});

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

@@ -83,42 +83,29 @@ export class AssetReplacedDto {
 @Injectable()
 export class AssetsService {
     constructor(
-        private readonly http: ProgressHttp,
+        private readonly authService: AuthService,
         private readonly apiUrl: ApiUrlConfig,
-        private readonly authService: AuthService
+        private readonly http: ProgressHttp
     ) {
     }
 
     public getAssets(appName: string, take: number, skip: number, query: string, mimeTypes: string[]): Observable<AssetsDto> {
-        let fullQuery = query ? query.trim() : '';
+        let queries: string[] = [];
 
         if (mimeTypes && mimeTypes.length > 0) {
-            let mimeQuery = '&mimeTypes=';
+            queries.push(`mimeTypes=${mimeTypes.join(',')}`);
-
-            for (let i = 0; i < mimeTypes.length; i++) {
-                mimeQuery += mimeTypes[0];
-
-                if (i > 0) {
-                    mimeQuery += ',';
-                }
-            }
-
-            fullQuery += mimeQuery;
         }
 
         if (query && query.length > 0) {
-            fullQuery += `&query=${query}`;
+            queries.push(`query=${query}`);
         }
 
-        if (take > 0) {
+        queries.push(`take=${take}`);
-            fullQuery += `&take=${take}`;
+        queries.push(`skip=${skip}`);
-        }
 
-        if (skip > 0) {
+        const fullQuery = queries.join('&');
-            fullQuery += `&skip=${skip}`;
-        }
 
-        const url = this.apiUrl.buildUrl(`api/apps/${appName}/assets/?${fullQuery}`);
+        const url = this.apiUrl.buildUrl(`api/apps/${appName}/assets?${fullQuery}`);
 
         return this.authService.authGet(url)
                 .map(response => response.json())
@@ -147,7 +134,7 @@ export class AssetsService {
 
     public uploadFile(appName: string, file: File): Observable<number | AssetCreatedDto> {
         return new Observable<number | AssetCreatedDto>(subscriber => {
-            const url = this.apiUrl.buildUrl(`api/apps/${appName}/assets/`);
+            const url = this.apiUrl.buildUrl(`api/apps/${appName}/assets`);
 
             const content = new FormData();
             const headers = new Headers({
@@ -221,7 +208,7 @@ export class AssetsService {
         });
     }
 
-    public updateAsset(appName: string, id: string, dto: UpdateAssetDto, version: Version): Observable<any> {
+    public putAsset(appName: string, id: string, dto: UpdateAssetDto, version: Version): Observable<any> {
         const url = this.apiUrl.buildUrl(`api/apps/${appName}/assets/${id}`);
 
         return this.authService.authPut(url, dto, version)

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

@@ -103,6 +103,7 @@ describe('ContentsService', () => {
         contentsService.getContents('my-app', 'my-schema', 17, 13, 'my-query').subscribe(result => {
             contents = result;
         }).unsubscribe();
+
         authService.verifyAll();
     });
 
@@ -125,6 +126,7 @@ describe('ContentsService', () => {
         contentsService.getContents('my-app', 'my-schema', 17, 13, '$filter=my-filter').subscribe(result => {
             contents = result;
         }).unsubscribe();
+
         authService.verifyAll();
     });
 

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

@@ -28,7 +28,7 @@ describe('UsersService', () => {
     });
 
     it('should make get request to get many users', () => {
-        authService.setup(x => x.authGet('http://service/p/api/users/?query='))
+        authService.setup(x => x.authGet('http://service/p/api/users?query='))
             .returns(() => Observable.of(
                 new Response(
                     new ResponseOptions({
@@ -66,7 +66,7 @@ describe('UsersService', () => {
     });
 
     it('should make get request with query to get many users', () => {
-        authService.setup(x => x.authGet('http://service/p/api/users/?query=my-query'))
+        authService.setup(x => x.authGet('http://service/p/api/users?query=my-query'))
             .returns(() => Observable.of(
                 new Response(
                     new ResponseOptions({
@@ -142,7 +142,7 @@ describe('UserManagementService', () => {
     });
 
     it('should make get request to get many users', () => {
-        authService.setup(x => x.authGet('http://service/p/api/user-management/?take=20&skip=30&query='))
+        authService.setup(x => x.authGet('http://service/p/api/user-management?take=20&skip=30&query='))
             .returns(() => Observable.of(
                 new Response(
                     new ResponseOptions({
@@ -183,7 +183,7 @@ describe('UserManagementService', () => {
     });
 
     it('should make get request with query to get many users', () => {
-        authService.setup(x => x.authGet('http://service/p/api/user-management/?take=20&skip=30&query=my-query'))
+        authService.setup(x => x.authGet('http://service/p/api/user-management?take=20&skip=30&query=my-query'))
             .returns(() => Observable.of(
                 new Response(
                     new ResponseOptions({

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

@@ -41,7 +41,7 @@ export class UsersService {
     }
 
     public getUsers(query?: string): Observable<UserDto[]> {
-        const url = this.apiUrl.buildUrl(`api/users/?query=${query || ''}`);
+        const url = this.apiUrl.buildUrl(`api/users?query=${query || ''}`);
 
         return this.authService.authGet(url)
                 .map(response => response.json())
@@ -86,7 +86,7 @@ export class UserManagementService {
     }
 
     public getUsers(take: number, skip: number, query?: string): Observable<UsersDto> {
-        const url = this.apiUrl.buildUrl(`api/user-management/?take=${take}&skip=${skip}&query=${query || ''}`);
+        const url = this.apiUrl.buildUrl(`api/user-management?take=${take}&skip=${skip}&query=${query || ''}`);
 
         return this.authService.authGet(url)
                 .map(response => response.json())