Adds symbol post and delete support (#31)

Fixes #30

Author: bobbyg603

package-lock.json

@@ -33,7 +33,8 @@
     "argument-contracts": "^1.2.3",
     "fetch-ponyfill": "^7.1.0",
     "form-data": "^4.0.0",
-    "node-fetch": "^2.6.1"
+    "node-fetch": "^2.6.1",
+    "rxjs": "^7.1.0"
   },
   "devDependencies": {
     "@types/jasmine": "^3.7.4",

package.json

@@ -1,4 +1,8 @@
-export function createFakeResponseBody(status, json, headers) {
+export function createFakeResponseBody(
+    status: number,
+    json: any = {},
+    headers: any = []
+) {
     return {
         status: status,
         json: async() => (json),

spec/fakes/common/response.ts

@@ -1,3 +1,4 @@
 export * from './common';
 export * from './crash';
-export * from './events';
+export * from './events';
+export * from './symbols';

src/index.ts

@@ -0,0 +1,11 @@
+import fs from 'fs';
+
+export function exists(file: string): boolean {
+    try {
+        fs.accessSync(file);
+    } catch {
+        return false;
+    }
+
+    return true;
+}

src/symbols/exists.ts

@@ -0,0 +1 @@
+export { SymbolsApiClient } from './symbols-api-client/symbols-api-client';

src/symbols/index.ts

@@ -0,0 +1,77 @@
+import * as ExistsModule from '../exists';
+import { S3ApiClient } from './s3-api-client';
+
+describe('S3ApiClient', () => {
+    describe('uploadFileToPresignedUrl', () => {
+        let s3ApiClient;
+        let fakeReadStream;
+        let fakeSuccessResponse;
+        
+        beforeEach(() => {
+            fakeReadStream = '🦦';
+            fakeSuccessResponse = { status: 200 };
+            spyOn(ExistsModule, 'exists').and.returnValue(true);
+            s3ApiClient = new S3ApiClient();
+            s3ApiClient._fs = jasmine.createSpyObj('fs', ['createReadStream']);
+            s3ApiClient._fs.createReadStream.and.returnValue(fakeReadStream);
+            s3ApiClient._fetch = jasmine.createSpy();
+            s3ApiClient._fetch.and.resolveTo(fakeSuccessResponse);
+        });
+
+        it('should throw if file does not exist', async () => {
+            const path = '/file/not/found';
+            (<jasmine.Spy>ExistsModule.exists).and.returnValue(false);
+            await expectAsync(s3ApiClient.uploadFileToPresignedUrl('url', path)).toBeRejectedWithError(`File does not exist at path: ${path}!`);
+        });
+
+        it('should call fetch with presignedUrl', async () => {
+            const url = 'https://bugsplat.com';
+            const path = '/some/fake/path';
+
+            await s3ApiClient.uploadFileToPresignedUrl(url, path);
+
+            expect(s3ApiClient._fetch).toHaveBeenCalledWith(url, jasmine.anything());
+        });
+
+        it('should call fetch with init containing method and headers', async () => {
+            const url = 'https://bugsplat.com';
+            const path = '/some/fake/path';
+            const size = 1337;
+
+            await s3ApiClient.uploadFileToPresignedUrl(url, path, size);
+
+            expect(s3ApiClient._fetch).toHaveBeenCalledWith(
+                jasmine.anything(),
+                jasmine.objectContaining({
+                    method: 'PUT',
+                    headers: {
+                        'content-type': 'application/octet-stream',
+                        'content-length': `${size}`
+                    },
+                    body: fakeReadStream
+                })
+            );
+        });
+
+        it('should return response', async () => {
+            const url = 'https://bugsplat.com';
+            const path = '/some/fake/path';
+            const size = 1337;
+
+            const response = await s3ApiClient.uploadFileToPresignedUrl(url, path, size);
+
+            expect(response).toEqual(fakeSuccessResponse);
+        });
+
+        describe('error', () => {
+            it('should throw if response status is not 200', async () => {
+                const url = 'https://bugsplat.com';
+                const path = '/some/fake/path';
+                const size = 1337;
+                s3ApiClient._fetch.and.resolveTo({ status: 500 });
+
+                await expectAsync(s3ApiClient.uploadFileToPresignedUrl(url, path, size)).toBeRejectedWithError(`Error uploading ${path} to presignedUrl`);
+            });
+        });
+    });
+});

src/symbols/s3-api-client/s3-api-client.spec.ts

@@ -0,0 +1,30 @@
+import fetchPonyfill from 'fetch-ponyfill';
+import fs from 'fs';
+import { exists } from '../exists';
+
+export class S3ApiClient {
+
+    private _fetch = fetchPonyfill().fetch;
+    private _fs = fs;
+
+    async uploadFileToPresignedUrl(presignedUrl: string, file: string, size: number): Promise<Response> {
+        if (!exists(file)) {
+            throw new Error(`File does not exist at path: ${file}!`);
+        }
+
+        const response = await this._fetch(presignedUrl, {
+            method: 'PUT',
+            headers: {
+                'content-type': 'application/octet-stream',
+                'content-length': `${size}`
+            },
+            body: <any>this._fs.createReadStream(file),
+        });
+
+        if (response.status !== 200) {
+            throw new Error(`Error uploading ${file} to presignedUrl`);
+        }
+
+        return response;
+    }
+}

src/symbols/s3-api-client/s3-api-client.ts

@@ -0,0 +1,46 @@
+import { config } from "../../../spec/config";
+import { BugSplatApiClient } from "../../common";
+import { SymbolsApiClient } from "./symbols-api-client";
+
+describe('SymbolsApiClient', () => {
+    let client: SymbolsApiClient;
+    let host = config.host;
+    let email = config.email;
+    let password = config.password;
+
+    const database = 'fred';
+    const application = 'bugsplat-js-api-client';
+    const version = '1.0.0';
+
+    beforeEach(async () => {
+        const bugsplat = new BugSplatApiClient(host); 
+        await bugsplat.login(email, password);
+        client = new SymbolsApiClient(bugsplat);
+    });
+
+    describe('delete', () => {
+        it('should return 200 for delete with valid database, application and version', async () => {
+            const response = await client.delete(
+                database,
+                application,
+                version
+            );
+
+            expect(response.status).toEqual(200);
+        });
+    });
+
+    describe('post', () => {
+        it('should return 200 for post with valid database, application, version and files', async () => {
+            const file = './dist/cjs/index.js.map';
+            const response = await client.post(
+                database,
+                application,
+                version,
+                [file]
+            );
+
+            expect(response[0].status).toEqual(200);
+        });
+    });
+});