@nymphjs/tilmeld 1.0.0-beta.13 → 1.0.0-beta.131

package/src/Tilmeld.types.ts

@@ -1,5 +1,5 @@
-import Group, { GroupData } from './Group';
-import User, { UserData } from './User';
+import Group, { GroupData } from './Group.js';
+import User, { UserData } from './User.js';
 
 export type AccessControlData = {
   user?: User & UserData;
@@ -7,7 +7,7 @@ export type AccessControlData = {
   acUser?: number;
   acGroup?: number;
   acOther?: number;
-  acFull?: ((User & UserData) | (Group & GroupData))[];
-  acWrite?: ((User & UserData) | (Group & GroupData))[];
-  acRead?: ((User & UserData) | (Group & GroupData))[];
+  acFull?: string[];
+  acWrite?: string[];
+  acRead?: string[];
 };

package/src/User.testArtifacts.ts

@@ -0,0 +1,226 @@
+import { type Nymph, EntityUniqueConstraintError } from '@nymphjs/nymph';
+
+import type Tilmeld from './Tilmeld.js';
+import defaults from './conf/defaults.js';
+import { AccessControlError } from './errors/index.js';
+
+export function UserTest(
+  nymph: Nymph,
+  tilmeld: Tilmeld,
+  describe: (name: string, fn: () => void) => void,
+  it: (name: string, fn: () => void) => void,
+) {
+  const User = tilmeld.User;
+  const Group = tilmeld.Group;
+
+  describe('User', () => {
+    beforeAll(async () => {
+      // Ensure the tables exist.
+      try {
+        await User.factoryUsername('user');
+        await Group.factoryGroupname('group');
+      } catch (e) {
+        // ignore
+      }
+    });
+
+    async function makeNewUser() {
+      const newUser = await User.factory();
+
+      newUser.username = 'new-user';
+      newUser.email = 'newuser@localhost';
+      newUser.nameFirst = 'New';
+      newUser.nameLast = 'User';
+      newUser.name = 'New User';
+      newUser.$password('password');
+
+      return newUser;
+    }
+
+    it('new user passes validation', async () => {
+      const validUser = await makeNewUser();
+
+      expect(() => {
+        defaults.validatorUser({ config: defaults } as Tilmeld, validUser);
+      }).not.toThrow();
+    });
+
+    it("doesn't allow unknown keys", async () => {
+      const invalidUser = await makeNewUser();
+
+      // @ts-ignore: testing unknown keys
+      invalidUser.unknown = 'I should cause an error.';
+
+      expect(() => {
+        defaults.validatorUser({ config: defaults } as Tilmeld, invalidUser);
+      }).toThrow('Invalid User:  "unknown" is not allowed');
+    });
+
+    it("doesn't allow duplicate usernames", async () => {
+      tilmeld.config.generatePrimary = false;
+      class NoUsernameCheckUser extends User {
+        public async $checkUsername() {
+          return {
+            result: true,
+            message: 'No problem here!',
+          };
+        }
+      }
+
+      const newUserA = await NoUsernameCheckUser.factory();
+
+      newUserA.username = 'new-user';
+      newUserA.email = 'newusera@localhost';
+      newUserA.nameFirst = 'New';
+      newUserA.nameLast = 'User';
+      newUserA.name = 'New User';
+      newUserA.$password('password');
+
+      await newUserA.$saveSkipAC();
+
+      const newUserB = await NoUsernameCheckUser.factory();
+
+      newUserB.username = 'new-user';
+      newUserB.email = 'newuserb@localhost';
+      newUserB.nameFirst = 'New';
+      newUserB.nameLast = 'User';
+      newUserB.name = 'New User';
+      newUserB.$password('password');
+
+      try {
+        await newUserB.$saveSkipAC();
+
+        throw new Error("Shouldn't get here because of unique constraint.");
+      } catch (e: any) {
+        expect(e).toBeInstanceOf(EntityUniqueConstraintError);
+      }
+
+      await newUserA.$deleteSkipAC();
+
+      tilmeld.config.generatePrimary = true;
+    });
+
+    it("doesn't allow duplicate emails", async () => {
+      tilmeld.config.generatePrimary = false;
+      class NoEmailCheckUser extends User {
+        public async $checkEmail() {
+          return {
+            result: true,
+            message: 'No problem here!',
+          };
+        }
+      }
+
+      const newUserA = await NoEmailCheckUser.factory();
+
+      newUserA.username = 'new-user-a';
+      newUserA.email = 'newuser@localhost';
+      newUserA.nameFirst = 'New';
+      newUserA.nameLast = 'User';
+      newUserA.name = 'New User';
+      newUserA.$password('password');
+
+      await newUserA.$saveSkipAC();
+
+      const newUserB = await NoEmailCheckUser.factory();
+
+      newUserB.username = 'new-user-b';
+      newUserB.email = 'newuser@localhost';
+      newUserB.nameFirst = 'New';
+      newUserB.nameLast = 'User';
+      newUserB.name = 'New User';
+      newUserB.$password('password');
+
+      try {
+        await newUserB.$saveSkipAC();
+
+        throw new Error("Shouldn't get here because of unique constraint.");
+      } catch (e: any) {
+        expect(e).toBeInstanceOf(EntityUniqueConstraintError);
+      }
+
+      await newUserA.$deleteSkipAC();
+
+      tilmeld.config.generatePrimary = true;
+    });
+
+    it('allows a domain user', async () => {
+      const domainAdmin = await User.factory();
+
+      domainAdmin.username = 'admin';
+      domainAdmin.email = 'admin@localhost';
+      domainAdmin.nameFirst = 'Admin';
+      domainAdmin.nameLast = 'User';
+      domainAdmin.name = 'Admin User';
+      domainAdmin.$password('password');
+      domainAdmin.$grant('tilmeld/domain/example.com/admin');
+
+      await domainAdmin.$saveSkipAC();
+
+      // Log in the domain admin.
+      await tilmeld.fillSession(domainAdmin);
+
+      const domainUser = await User.factory();
+
+      domainUser.username = 'new-user@example.com';
+      domainUser.email = 'newuser@localhost';
+      domainUser.nameFirst = 'New';
+      domainUser.nameLast = 'User';
+      domainUser.name = 'New User';
+      domainUser.$password('password');
+
+      await domainUser.$save();
+
+      tilmeld.clearSession();
+
+      for (const user of [domainAdmin, domainUser]) {
+        if (user.guid != null) {
+          await user.$deleteSkipAC();
+        }
+      }
+    });
+
+    it('disallows a domain user with no admin permission', async () => {
+      const domainAdmin = await User.factory();
+
+      domainAdmin.username = 'admin';
+      domainAdmin.email = 'admin@localhost';
+      domainAdmin.nameFirst = 'Admin';
+      domainAdmin.nameLast = 'User';
+      domainAdmin.name = 'Admin User';
+      domainAdmin.$password('password');
+      domainAdmin.$grant('tilmeld/domain/example.com/admin');
+
+      await domainAdmin.$saveSkipAC();
+
+      // Log in the domain admin.
+      await tilmeld.fillSession(domainAdmin);
+
+      const domainUser = await User.factory();
+
+      // The wrong domain name.
+      domainUser.username = 'new-user@example.net';
+      domainUser.email = 'newuser@localhost';
+      domainUser.nameFirst = 'New';
+      domainUser.nameLast = 'User';
+      domainUser.name = 'New User';
+      domainUser.$password('password');
+
+      try {
+        await domainUser.$save();
+
+        throw new Error("Shouldn't get here because of access control.");
+      } catch (e: any) {
+        expect(e).toBeInstanceOf(AccessControlError);
+      }
+
+      tilmeld.clearSession();
+
+      for (const user of [domainAdmin, domainUser]) {
+        if (user.guid != null) {
+          await user.$deleteSkipAC();
+        }
+      }
+    });
+  });
+}