@stevenkellner/team-conduct-api 1.0.36 → 2.0.1

package/lib/test/firebase/checkAuthentication.test.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mocha_1 = require("mocha");
+const core_1 = require("@assertive-ts/core");
+const checkAuthentication_1 = require("../../src/firebase/checkAuthentication");
+const index_1 = require("../../src/types/index");
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const firebase_utils_1 = require("./firebase-utils");
+(0, mocha_1.describe)('checkAuthentication', () => {
+    const teamId = index_1.Team.Id.builder.build('11111111-1111-4111-1111-111111111111');
+    const personId = index_1.Person.Id.builder.build('22222222-2222-4222-2222-222222222222');
+    const userId = index_1.User.Id.builder.build('user123');
+    (0, mocha_1.describe)('checkAuthentication - basic validation', () => {
+        (0, mocha_1.it)('should throw "unauthenticated" error if rawUserId is null', async () => {
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(null, teamId, 'team-manager');
+            }, 'unauthenticated', 'User is not authenticated');
+        });
+        (0, mocha_1.it)('should throw "permission-denied" if user does not exist', async () => {
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.empty()
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, 'team-manager');
+            }, 'permission-denied', 'User does not exist');
+        });
+        (0, mocha_1.it)('should throw "permission-denied" if user is not a member of the team', async () => {
+            const emptyTeams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, emptyTeams)
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, 'team-manager');
+            }, 'permission-denied', 'User is not a member of the team');
+        });
+        (0, mocha_1.it)('should throw "permission-denied" if person does not exist', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.empty()
+                        })
+                    })
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, 'team-manager');
+            }, 'permission-denied', 'Person does not exist');
+        });
+        (0, mocha_1.it)('should throw "permission-denied" if person is not signed in', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.personNotSignedIn(personId)
+                        })
+                    })
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, 'team-manager');
+            }, 'permission-denied', 'Person is not signed in');
+        });
+    });
+    (0, mocha_1.describe)('checkAuthentication - role validation', () => {
+        (0, mocha_1.it)('should throw "permission-denied" if user does not have required single role', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['person-manager'])
+                        })
+                    })
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, 'team-manager');
+            }, 'permission-denied', 'User does not have the required roles');
+        });
+        (0, mocha_1.it)('should return userId if user has required single role', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['team-manager', 'person-manager'])
+                        })
+                    })
+                })
+            });
+            const result = await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, 'team-manager');
+            (0, core_1.expect)(result).toBeEqual(userId);
+        });
+        (0, mocha_1.it)('should throw "permission-denied" if user does not have all required roles (AND logic)', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['person-manager'])
+                        })
+                    })
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, ['person-manager', 'team-manager']);
+            }, 'permission-denied', 'User does not have the required roles');
+        });
+        (0, mocha_1.it)('should return userId if user has all required roles (AND logic)', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['person-manager', 'team-manager', 'fine-manager'])
+                        })
+                    })
+                })
+            });
+            const result = await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, ['person-manager', 'team-manager']);
+            (0, core_1.expect)(result).toBeEqual(userId);
+        });
+        (0, mocha_1.it)('should return userId if user has at least one required role (OR logic)', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['person-manager'])
+                        })
+                    })
+                })
+            });
+            const result = await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, { anyOf: ['person-manager', 'team-manager'] });
+            (0, core_1.expect)(result).toBeEqual(userId);
+        });
+        (0, mocha_1.it)('should throw "permission-denied" if user does not have any required role (OR logic)', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['fine-manager'])
+                        })
+                    })
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, { anyOf: ['person-manager', 'team-manager'] });
+            }, 'permission-denied', 'User does not have the required roles');
+        });
+        (0, mocha_1.it)('should handle complex nested role requirements (AND with OR)', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['person-manager', 'fine-manager'])
+                        })
+                    })
+                })
+            });
+            const result = await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, [
+                'person-manager',
+                { anyOf: ['fine-manager', 'team-manager'] }
+            ]);
+            (0, core_1.expect)(result).toBeEqual(userId);
+        });
+        (0, mocha_1.it)('should throw for complex nested requirements when not satisfied', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, ['person-manager'])
+                        })
+                    })
+                })
+            });
+            await (0, firebase_utils_1.expectThrowsFunctionsError)(async () => {
+                await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, [
+                    'person-manager',
+                    { anyOf: ['fine-manager', 'team-manager'] }
+                ]);
+            }, 'permission-denied', 'User does not have the required roles');
+        });
+    });
+    (0, mocha_1.describe)('checkAuthentication - comprehensive success scenarios', () => {
+        (0, mocha_1.it)('should return userId for fully authenticated user with all permissions', async () => {
+            const teams = new typescript_common_functionality_1.Dictionary(index_1.Team.Id.builder);
+            teams.set(teamId, index_1.User.TeamProperties.builder.build({
+                teamId: teamId.guidString,
+                teamName: 'Test Team',
+                personId: personId.guidString
+            }));
+            (0, firebase_utils_1.configureFirebase)({
+                users: firebase_utils_1.Collection.docs({
+                    [userId.value]: firebase_utils_1.Document.user(userId, teams)
+                }),
+                teams: firebase_utils_1.Collection.docs({
+                    [teamId.guidString]: firebase_utils_1.Document.colls({
+                        persons: firebase_utils_1.Collection.docs({
+                            [personId.guidString]: firebase_utils_1.Document.person(personId, userId, [
+                                'person-manager',
+                                'team-manager',
+                                'fine-manager',
+                                'fine-can-add',
+                                'fineTemplate-manager'
+                            ])
+                        })
+                    })
+                })
+            });
+            const result = await (0, checkAuthentication_1.checkAuthentication)(userId.value, teamId, 'fine-can-add');
+            (0, core_1.expect)(result).toBeEqual(userId);
+        });
+    });
+});

package/lib/test/firebase/firebase-utils.d.ts

@@ -0,0 +1,32 @@
+import { User, Team, Person, NotificationProperties, UserRole } from '../../src/types/index';
+import { Dictionary } from '@stevenkellner/typescript-common-functionality';
+import type { FunctionsErrorCode } from '@stevenkellner/firebase-function';
+import { FunctionsError } from '@stevenkellner/firebase-function';
+import { Messaging } from '../../src';
+export declare class Collection {
+    readonly documents: Record<string, Document>;
+    private constructor();
+    document(key: string): Document;
+    static docs(documents: Record<string, Document>): Collection;
+}
+export declare class Document {
+    readonly collections: Record<string, Collection>;
+    data: any;
+    private constructor();
+    collection(key: string): Collection;
+    snapshot(): {
+        exists: boolean;
+        data: any;
+    };
+    set(values: any): void;
+    static colls(collections: Record<string, Collection>): Document;
+    static data(data: any): Document;
+    static empty(): Document;
+    static collsAndData(collections: Record<string, Collection>, data: any): Document;
+    static user(id: User.Id, teams: Dictionary<Team.Id, User.TeamProperties>): Document;
+    static personNotSignedIn(id: Person.Id): Document;
+    static person(id: Person.Id, userId: User.Id, roles: UserRole[]): Document;
+    static personWithSubscriptions(id: Person.Id, subscriptions: NotificationProperties.Subscription[], tokens?: Dictionary<NotificationProperties.TokenId, string>): Document;
+}
+export declare function expectThrowsFunctionsError(fn: () => Promise<any>, expectedCode: FunctionsErrorCode, message?: string | null): Promise<FunctionsError>;
+export declare function configureFirebase(collections: Record<string, Collection>, messaging?: Messaging): void;

package/lib/test/firebase/firebase-utils.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Document = exports.Collection = void 0;
+exports.expectThrowsFunctionsError = expectThrowsFunctionsError;
+exports.configureFirebase = configureFirebase;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const core_1 = require("@assertive-ts/core");
+const index_1 = require("../../src/types/index");
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const firebase_function_1 = require("@stevenkellner/firebase-function");
+const src_1 = require("../../src");
+class Collection {
+    documents;
+    constructor(documents) {
+        this.documents = documents;
+    }
+    document(key) {
+        const documentData = this.documents[key];
+        if (!documentData)
+            throw new Error(`Unexpected document key: ${key}`);
+        return documentData;
+    }
+    static docs(documents) {
+        return new Collection(documents);
+    }
+}
+exports.Collection = Collection;
+class Document {
+    collections;
+    data;
+    constructor(collections, data) {
+        this.collections = collections;
+        this.data = data;
+    }
+    collection(key) {
+        const collectionData = this.collections[key];
+        if (!collectionData)
+            throw new Error(`Unexpected collection key: ${key}`);
+        return collectionData;
+    }
+    snapshot() {
+        return {
+            exists: this.data !== undefined,
+            data: this.data
+        };
+    }
+    set(values) {
+        this.data = typescript_common_functionality_1.Flattable.flatten(values);
+    }
+    static colls(collections) {
+        return new Document(collections, undefined);
+    }
+    static data(data) {
+        return new Document({}, data);
+    }
+    static empty() {
+        return new Document({}, undefined);
+    }
+    static collsAndData(collections, data) {
+        return new Document(collections, data);
+    }
+    static user(id, teams) {
+        return Document.data(index_1.User.builder.build({
+            id: id.value,
+            teams: teams.flatten
+        }).flatten);
+    }
+    static personNotSignedIn(id) {
+        return Document.data(index_1.Person.builder.build({
+            id: id.guidString,
+            properties: index_1.PersonPrivateProperties.builder.build({
+                firstName: 'Test',
+                lastName: 'User'
+            }).flatten,
+            fineIds: [],
+            signInProperties: null
+        }).flatten);
+    }
+    static person(id, userId, roles) {
+        return Document.data(index_1.Person.builder.build({
+            id: id.guidString,
+            properties: index_1.PersonPrivateProperties.builder.build({
+                firstName: 'Test',
+                lastName: 'User'
+            }).flatten,
+            fineIds: [],
+            signInProperties: index_1.PersonSignInProperties.builder.build({
+                signInDate: typescript_common_functionality_1.UtcDate.now.flatten,
+                userId: userId.value,
+                notificationProperties: new index_1.NotificationProperties().flatten,
+                roles: roles
+            }).flatten
+        }).flatten);
+    }
+    static personWithSubscriptions(id, subscriptions, tokens) {
+        return Document.data(index_1.Person.builder.build({
+            id: id.guidString,
+            properties: index_1.PersonPrivateProperties.builder.build({
+                firstName: 'Test',
+                lastName: 'User'
+            }).flatten,
+            fineIds: [],
+            signInProperties: index_1.PersonSignInProperties.builder.build({
+                signInDate: typescript_common_functionality_1.UtcDate.now.flatten,
+                userId: 'user-123',
+                notificationProperties: new index_1.NotificationProperties(tokens, subscriptions).flatten,
+                roles: []
+            }).flatten
+        }).flatten);
+    }
+}
+exports.Document = Document;
+async function expectThrowsFunctionsError(fn, expectedCode, message = null) {
+    try {
+        await fn();
+        throw new Error('Expected function to throw a FunctionsError');
+    }
+    catch (error) {
+        (0, core_1.expect)(error).toBeInstanceOf(firebase_function_1.FunctionsError);
+        (0, core_1.expect)(error.code).toBeEqual(expectedCode);
+        if (message !== null)
+            (0, core_1.expect)(error.message).toBeEqual(message);
+        return error;
+    }
+}
+function configureFirebase(collections, messaging) {
+    src_1.FirebaseConfiguration.shared.reconfigure({
+        baseFirestoreDocument: Document.colls(collections),
+        messaging: messaging
+    });
+}

package/lib/test/firebase/pushNotification.test.d.ts

@@ -0,0 +1 @@
+export {};