Start adding integration tests on app (#49)

* setup jest

* split app creation and app launch

* Add tests for file and history endpoints

* fix package-lock.json

* update package-lock

* add sinon as an explicit dependency

Author: Cgg

app.test.ts

@@ -0,0 +1,64 @@
+import supertest from 'supertest';
+import { ImportMock } from 'ts-mock-imports';
+
+import { pprint } from './src/helpers';
+import * as Ledger from './src/ledger';
+
+import app from './app';
+
+// TODO
+// - isolate test env (pass outDir as a param to app, create a specific outDir
+//   for test)
+// - test that an existing file is returned
+// - test that an existing dotFile is not returned
+describe('The file endpoint', () => {
+  it('should 404 if the file doesnt exist.', () => {
+    return supertest(app)
+      .get('/file/foo')
+      .then(response => {
+        expect(response.status).toBe(404);
+      });
+  });
+
+  it('should 200 with the file if it exists', () => {
+    // create a file in the test dir
+    // ask for it
+    // file is returned
+  });
+
+  it('should not return an existing dot file', () => {
+    // create a dot file in the test dir
+    // ask for it
+    // file is not returned
+  });
+});
+
+describe('The history endpoint', () => {
+  afterEach(() => {
+    ImportMock.restore();
+  });
+
+  it("should use the ledger's history API", () => {
+    const result = { foo: 'bar' };
+
+    const getListHistoryMock = ImportMock.mockFunction(
+      Ledger,
+      'listDocHistory',
+      Promise.resolve(result)
+    );
+
+    const name = 'foo';
+
+    return supertest(app)
+      .get(`/history/${name}`)
+      .then(response => {
+        expect(getListHistoryMock.calledOnce).toBe(true);
+        expect(getListHistoryMock.calledWith(name)).toBe(true);
+
+        expect(response.status).toBe(200);
+        expect(response.text).toBe(pprint(result));
+      });
+  });
+});
+
+describe('The export-copy endpoint', () => {});

app.ts

@@ -0,0 +1,177 @@
+import express, { Application, Request, Response } from 'express';
+import { config } from 'dotenv';
+import { join } from 'path';
+import cors from 'cors';
+import sharp from 'sharp';
+import formidable, { Fields, Files } from 'formidable';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import { parse } from 'path';
+
+import * as Ledger from './src/ledger';
+import * as Store from './src/store';
+import * as Bundle from './src/types/Bundle';
+import * as Record from './src/types/Record';
+import * as Verify from './src/verify';
+
+import { pprint, cleanupBase64 } from './src/helpers';
+
+// set up .env variables as environment variables
+config();
+
+const app: Application = express();
+
+app.use(cors());
+
+// Body parsing Middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.get('/file/:sku', async (req: Request, res: Response): Promise<void> => {
+  const { sku } = req.params;
+  const options = {
+    root: join(__dirname, './out'),
+    dotfiles: 'deny',
+  };
+  res.sendFile(`${sku}`, options);
+});
+
+app.get(
+  '/history/:sku',
+  async (req: Request, res: Response): Promise<Response> => {
+    const { sku } = req.params;
+    const result = await Ledger.listDocHistory(sku);
+    console.log(chalk.bold(`GET /history/${sku}`));
+    return res.status(200).send(pprint(result));
+  }
+);
+
+app.get(
+  '/export-copy/:sku',
+  async (req: Request, res: Response): Promise<void> => {
+    const { sku } = req.params;
+    const rootDir = join(__dirname, './out');
+    const options = {
+      root: rootDir,
+      dotfiles: 'deny',
+    };
+    // `sku` comes with .zip at the end, which we must remove
+    const cleanSku = parse(sku).name;
+    await Ledger.getDoc(cleanSku, 'id')
+      .then(r => Store.makeZip(r, rootDir, rootDir))
+      .then(() =>
+        res
+          .set(`Content-Type`, `application/octet-stream`)
+          .set(`Content-Disposition`, `attachment; filename=${sku}`)
+          .sendFile(`${sku}`, options)
+      );
+  }
+);
+
+app.get(
+  '/list-docs',
+  async (req: Request, res: Response): Promise<Response> => {
+    const result = await Ledger.listDocs();
+    console.log(chalk.bold(`GET /list-docs`));
+    return res.status(200).send(pprint(result));
+  }
+);
+
+app.post('/form', async (req: Request, res: Response): Promise<Response> => {
+  console.log(chalk.bold(`POST /form`));
+  return new Promise((resolve, reject) => {
+    const form = new formidable.IncomingForm();
+    form.parse(req, async (err: Error, fields: Fields): Promise<void> => {
+      if (err) {
+        resolve(res.status(400).send(`${err.name}: ${err.message}`)); // FIXME: don't expose js errors to public
+      }
+      const { url, title, scr } = fields;
+      const base64Data = cleanupBase64(scr as string); // FIXME: don't use 'as string', instead make sure we have string instead of string[]
+      const screenshotData = new Buffer(base64Data, 'base64');
+      const thumbnailData = await sharp(screenshotData)
+        .resize(320, 240, { fit: 'inside' })
+        .toBuffer();
+      let onefileData: string;
+      onefileData = fields.onefile as string;
+
+      const screenshot = { kind: 'screenshot' as const, data: screenshotData };
+      const thumbnail = {
+        kind: 'screenshot_thumbnail' as const,
+        data: thumbnailData,
+      };
+      const onefile = { kind: 'one_file' as const, data: onefileData };
+
+      await Store.newBundle([screenshot, thumbnail, onefile])
+        .then((bundle: Bundle.Bundle) => {
+          const record = {
+            bundle,
+            annotations: { description: '' },
+            data: { url: url as string, title: title as string },
+          };
+          return record;
+        })
+        .then((r: Record.Record) => {
+          return Ledger.insertDoc(r);
+        })
+        .then(_ => {
+          console.log(`ledger inserted correctly`);
+          resolve(res.status(200).send('Received POST on /form'));
+        })
+        .catch(e => {
+          resolve(
+            res.status(422).send(`${e.name} (type ${e.type}): ${e.message}`)
+          );
+        });
+    });
+  });
+});
+
+app.post(
+  '/edit-description/:sku',
+  async (req: Request, res: Response): Promise<Response> => {
+    const { sku } = req.params;
+    console.log(chalk.bold(`POST /edit-description/${sku}`));
+    return new Promise((resolve, reject) => {
+      const form = new formidable.IncomingForm();
+      form.parse(req, async (err: Error, fields: Fields): Promise<void> => {
+        if (err) {
+          resolve(res.status(400).send(`${err.name}: ${err.message}`)); // FIXME: don't expose js errors to public
+        }
+        const { description } = fields;
+        const update = { description: description as string };
+        Ledger.updateDoc(sku, update);
+
+        resolve(res.status(200).send(`Wrote description to ${sku}`));
+      });
+    });
+  }
+);
+
+app.post('/verify', async (req: Request, res: Response): Promise<Response> => {
+  console.log(chalk.bold(`POST /verify`));
+  return new Promise((resolve, reject) => {
+    const form = new formidable.IncomingForm();
+    form.parse(req, async (err: Error, fields: Fields, files: Files) => {
+      // verify each file by opening it and sending it to check
+      // (which involves hashing and comparing to QLDB), then building
+      // the Response one file at a time and sending it once
+      Promise.all(
+        Object.keys(files).map(async i => {
+          await fs
+            // @ts-expect-error
+            .readFile(files[i].path)
+            .then(f => Verify.verifyFile(f))
+            .then(result =>
+              res.write(
+                result
+                  ? JSON.stringify(result)
+                  : JSON.stringify({ not_found: 'item not found' })
+              )
+            );
+        })
+      ).then(() => resolve(res.send()));
+    });
+  });
+});
+
+export default app;