@stanlemon/server-with-auth 0.1.3 → 0.1.6

package/jest.config.js

@@ -0,0 +1 @@
+export { default } from "@stanlemon/webdev/jest.config.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanlemon/server-with-auth",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "A basic express web server setup with authentication baked in.",
   "author": "Stan Lemon <stanlemon@users.noreply.github.com>",
   "license": "MIT",
@@ -14,11 +14,13 @@
     "start": "NODE_ENV=development nodemon --ignore db.json ./app.js",
     "lint": "eslint --ext js,jsx,ts,tsx ./",
     "lint:format": "eslint --fix --ext js,jsx,ts,tsx ./",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --watch"
+    "test": "jest --detectOpenHandles",
+    "test:coverage": "jest --detectOpenHandles --coverage",
+    "test:watch": "jest --detectOpenHandles --watch"
   },
   "dependencies": {
     "@stanlemon/server": "*",
+    "@stanlemon/webdev": "*",
     "bcryptjs": "^2.4.3",
     "jsonwebtoken": "^8.5.1",
     "lowdb": "^3.0.0",
@@ -29,7 +31,8 @@
   },
   "devDependencies": {
     "@stanlemon/eslint-config": "*",
-    "nodemon": "^2.0.15",
-    "supertest": "^6.2.2"
+    "@types/supertest": "^2.0.12",
+    "nodemon": "^2.0.16",
+    "supertest": "^6.2.3"
   }
 }

package/src/createAppServer.js

@@ -5,6 +5,7 @@ import {
 } from "@stanlemon/server";
 import passport from "passport";
 import { Strategy as JwtStrategy, ExtractJwt } from "passport-jwt";
+import shortid from "shortid";
 import defaultUserSchema from "./schema/user.js";
 import checkAuth from "./checkAuth.js";
 import auth from "./routes/auth.js";
@@ -39,13 +40,17 @@ export default function createAppServer(options) {
     updateUser,
   } = { ...DEFAULTS, ...options };
 
+  const app = createBaseAppServer({ port, webpack, start });
+
+  if (process.env.NODE_ENV === "test") {
+    return app;
+  }
+
   if (!process.env.JWT_SECRET) {
     console.warn("You need to specify a secret.");
   }
 
-  const secret = process.env.JWT_SECRET || "YouNeedASecret";
-
-  const app = createBaseAppServer({ port, webpack, start });
+  const secret = process.env.JWT_SECRET || shortid.generate();
 
   passport.use(
     "jwt",

package/src/data/simple-users-dao.js

@@ -1,10 +1,13 @@
-import { Low, JSONFile } from "lowdb";
+import { Low, JSONFile, Memory } from "lowdb";
 import { v4 as uuidv4 } from "uuid";
 import shortid from "shortid";
 import bcrypt from "bcryptjs";
 
+const DEFAULT_ADAPTER =
+  process.env.NODE_ENV === "test" ? new Memory() : new JSONFile("./db.json");
+
 export default class SimpleUsersDao {
-  constructor(seeds = [], adapter = new JSONFile("./db.json")) {
+  constructor(seeds = [], adapter = DEFAULT_ADAPTER) {
     this.db = new Low(adapter);
 
     this.db.read().then(() => {
@@ -16,6 +19,18 @@ export default class SimpleUsersDao {
     });
   }
 
+  getDb() {
+    return this.db;
+  }
+
+  generateId() {
+    return uuidv4();
+  }
+
+  generateVerificationToken() {
+    return shortid.generate();
+  }
+
   getUserById = (userId) => {
     return this.db.data.users
       .filter((user) => {
@@ -42,7 +57,7 @@ export default class SimpleUsersDao {
 
     const user = this.getUserByUsername(username);
 
-    if (!bcrypt.compareSync(password, user.password)) {
+    if (!user || !bcrypt.compareSync(password, user.password)) {
       return false;
     }
 
@@ -66,8 +81,8 @@ export default class SimpleUsersDao {
     const data = {
       ...user,
       password: bcrypt.hashSync(user.password, 10),
-      id: uuidv4(),
-      verification_token: shortid.generate(),
+      id: this.generateId(),
+      verification_token: this.generateVerificationToken(),
       created_at: now,
       last_updated: now,
     };

package/src/data/simple-users-dao.test.js

@@ -0,0 +1,95 @@
+/**
+ * @jest-environment node
+ */
+import { Memory } from "lowdb";
+import SimpleUsersDao from "./simple-users-dao.js";
+
+describe("simple-users-dao", () => {
+  // This is a user that we will reuse in our tests
+  const data = {
+    username: "test",
+    password: "password",
+  };
+  // This will be our user database
+  let users;
+
+  beforeEach(() => {
+    // Before each test reset our users database
+    users = new SimpleUsersDao([], new Memory());
+  });
+
+  it("creates a user", async () => {
+    let user = await users.createUser(data);
+
+    expect(user.username).toEqual(data.username);
+    // The value should be encrypted now
+    expect(user.password).not.toEqual(data.password);
+    // These fields are added by the create process
+    expect(user.verification_token).not.toBeUndefined();
+    expect(user.created_at).not.toBeUndefined();
+    expect(user.last_updated).not.toBeUndefined();
+
+    const refresh = users.getUserByUsername(data.username);
+
+    // If we retrieve the user by username, it matches the object we got when we created it
+    expect(refresh).toMatchObject(user);
+  });
+
+  it("creates a user with an existing username errors", async () => {
+    let hasError = false;
+
+    try {
+      // Create the user
+      await users.createUser(data);
+      // Attempt to create the user again, this will fail
+      await users.createUser(data);
+    } catch (err) {
+      hasError = err;
+    }
+
+    expect(hasError).not.toBe(false);
+    expect(hasError.message).toEqual("This username is already taken.");
+  });
+
+  it("retrieve user by username and password", async () => {
+    const user1 = await users.createUser(data);
+
+    const user2 = users.getUserByUsernameAndPassword(
+      data.username,
+      data.password
+    );
+
+    expect(user1).toMatchObject(user2);
+  });
+
+  it("retrieve user by username and wrong password fails", async () => {
+    await users.createUser(data);
+
+    const user2 = users.getUserByUsernameAndPassword(
+      data.username,
+      "wrong password"
+    );
+
+    expect(user2).toBe(false);
+  });
+
+  it("retrieve user by username and undefined password fails", async () => {
+    await users.createUser(data);
+
+    const user2 = users.getUserByUsernameAndPassword(data.username, undefined);
+
+    expect(user2).toBe(false);
+  });
+
+  it("retrieve user by username that does not exist fails", async () => {
+    const user = users.getUserByUsernameAndPassword("notarealuser", "password");
+
+    expect(user).toBe(false);
+  });
+
+  it("retrieve user by username that is undefined fails", async () => {
+    const user = users.getUserByUsernameAndPassword(undefined, "password");
+
+    expect(user).toBe(false);
+  });
+});

package/src/routes/auth.test.js

@@ -1,11 +1,20 @@
+/**
+ * @jest-environment node
+ */
 import request from "supertest";
 import { Memory } from "lowdb";
 import createAppServer from "../createAppServer";
 import SimpleUsersDao from "../data/simple-users-dao.js";
 
+// This suppresses a warning we don't need in tests
+process.env.JWT_SECRET = "SECRET";
+
 let users = new SimpleUsersDao([], new Memory());
 
+// We want to explicitly test functionality we disable during testing
+process.env.NODE_ENV = "override";
 const app = createAppServer({ ...users, start: false });
+process.env.NODE_ENV = "test";
 
 describe("/auth", () => {
   let userId;