@stevenkellner/team-conduct-api 1.0.2 → 1.0.4

package/test/functions/invitation/register.test.ts

@@ -1,137 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Dictionary, Result, Tagged } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-import { Invitation, Team, User } from '../../../src/types';
-
-describe('InvitationRegisterFunction', () => {
-
-    let userId: User.Id;
-
-    beforeEach(async () => {
-        userId = await FirebaseApp.shared.addTestTeam('team-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('not signed in', async () => {
-        const invitationId = await FirebaseApp.shared.functions.invitation.invite.execute(new Invitation(
-            FirebaseApp.shared.testTeam.id,
-            FirebaseApp.shared.testTeam.persons[1].id
-        ));
-        await FirebaseApp.shared.auth.signOut();
-        const result = await FirebaseApp.shared.functions.invitation.register.executeWithResult(invitationId);
-        expect(result).toBeEqual(Result.failure(new FunctionsError('unauthenticated', 'User not authenticated')));
-    });
-
-    it('invitation not found', async () => {
-        const result = await FirebaseApp.shared.functions.invitation.register.executeWithResult(new Tagged('no-invitation', 'invitation'));
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Invitation not found')));
-    });
-
-    it('user already in team', async () => {
-        const invitationId = await FirebaseApp.shared.functions.invitation.invite.execute(new Invitation(
-            FirebaseApp.shared.testTeam.id,
-            FirebaseApp.shared.testTeam.persons[1].id
-        ));
-        const result = await FirebaseApp.shared.functions.invitation.register.executeWithResult(invitationId);
-        expect(result).toBeEqual(Result.failure(new FunctionsError('already-exists', 'User already in team')));
-    });
-
-    it('person not found', async () => {
-        const invitationId = await FirebaseApp.shared.functions.invitation.invite.execute(new Invitation(
-            FirebaseApp.shared.testTeam.id,
-            FirebaseApp.shared.testTeam.persons[1].id
-        ));
-        await FirebaseApp.shared.firestore.user(userId).remove();
-        await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[1].id).remove();
-        const result = await FirebaseApp.shared.functions.invitation.register.executeWithResult(invitationId);
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Person not found')));
-    });
-
-    it('register not existing user', async () => {
-        const invitationId = await FirebaseApp.shared.functions.invitation.invite.execute(new Invitation(
-            FirebaseApp.shared.testTeam.id,
-            FirebaseApp.shared.testTeam.persons[1].id
-        ));
-        await FirebaseApp.shared.firestore.user(userId).remove();
-        const user = await FirebaseApp.shared.functions.invitation.register.execute(invitationId);
-        expect(user).toBeEqual(new User(userId, new Dictionary(Team.Id.builder, {
-            [FirebaseApp.shared.testTeam.id.guidString]: new User.TeamProperties(FirebaseApp.shared.testTeam.name, FirebaseApp.shared.testTeam.persons[1].id)
-        })));
-        const invitationSnapshot = await FirebaseApp.shared.firestore.invitation(invitationId).snapshot();
-        expect(invitationSnapshot.exists).toBeFalse();
-        const userSnapshot = await FirebaseApp.shared.firestore.user(userId).snapshot();
-        expect(userSnapshot.exists).toBeTrue();
-        expect(userSnapshot.data).toBeEqual({
-            id: userId.value,
-            teams: {
-                [FirebaseApp.shared.testTeam.id.guidString]: {
-                    name: FirebaseApp.shared.testTeam.name,
-                    personId: FirebaseApp.shared.testTeam.persons[1].id.guidString
-                }
-            }
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[1].id).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data.signInProperties !== null).toBeEqual(true);
-        expect(personSnapshot.data).toBeEqual({
-            ...personSnapshot.data,
-            signInProperties: {
-                userId: userId.value,
-                signInDate: personSnapshot.data.signInProperties!.signInDate,
-                notificationProperties: {
-                    tokens: {},
-                    subscriptions: []
-                },
-                roles: []
-            }
-        });
-    });
-
-    it('register existing user', async () => {
-        const invitationId = await FirebaseApp.shared.functions.invitation.invite.execute(new Invitation(
-            FirebaseApp.shared.testTeam.id,
-            FirebaseApp.shared.testTeam.persons[1].id
-        ));
-        const signedInUser = new User(userId);
-        signedInUser.teams.set(RandomData.shared.teamId(), new User.TeamProperties('team-1', Tagged.generate('person')));
-        await FirebaseApp.shared.firestore.user(userId).set(signedInUser);
-        const user = await FirebaseApp.shared.functions.invitation.register.execute(invitationId);
-        const userSnapshot = await FirebaseApp.shared.firestore.user(userId).snapshot();
-        expect(userSnapshot.exists).toBeTrue();
-        expect(userSnapshot.data).toBeEqual({
-            id: userId.value,
-            teams: {
-                ...userSnapshot.data.teams,
-                [FirebaseApp.shared.testTeam.id.guidString]: {
-                    name: FirebaseApp.shared.testTeam.name,
-                    personId: FirebaseApp.shared.testTeam.persons[1].id.guidString
-                }
-            }
-        });
-        signedInUser.teams.set(FirebaseApp.shared.testTeam.id, new User.TeamProperties(FirebaseApp.shared.testTeam.name, FirebaseApp.shared.testTeam.persons[1].id));
-        expect(user).toBeEqual(new User(userId, signedInUser.teams));
-        const invitationSnapshot = await FirebaseApp.shared.firestore.invitation(invitationId).snapshot();
-        expect(invitationSnapshot.exists).toBeFalse();
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[1].id).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data.signInProperties !== null).toBeEqual(true);
-        expect(personSnapshot.data).toBeEqual({
-            ...personSnapshot.data,
-            signInProperties: {
-                userId: userId.value,
-                 
-                signInDate: personSnapshot.data.signInProperties!.signInDate,
-                notificationProperties: {
-                    tokens: {},
-                    subscriptions: []
-                },
-                roles: []
-            }
-        });
-    });
-});

package/test/functions/invitation/withdraw.test.ts

@@ -1,33 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { Invitation } from '../../../src/types';
-
-describe('InvitationWithdrawFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('team-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('invitation not found', async () => {
-        const result = await FirebaseApp.shared.functions.invitation.withdraw.executeWithResult(new Invitation(
-            FirebaseApp.shared.testTeam.id,
-            FirebaseApp.shared.testTeam.persons[1].id
-        ));
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Invitation not found')));
-    });
-
-    it('should withdraw', async () => {
-        const invitation = new Invitation(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[1].id);
-        const invitationId = invitation.createId();
-        await FirebaseApp.shared.firestore.invitation(invitationId).set(invitation);
-        await FirebaseApp.shared.functions.invitation.withdraw.execute(invitation);
-        const invitationSnapshot = await FirebaseApp.shared.firestore.invitation(invitationId).snapshot();
-        expect(invitationSnapshot.exists).toBeFalse();
-    });
-});

package/test/functions/notifcation/register.test.ts

@@ -1,47 +0,0 @@
-import { NotificationProperties } from './../../../src/types/NotificationProperties';
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-
-describe('NotificationRegisterFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('fineTemplate-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('person not found', async () => {
-        const result = await FirebaseApp.shared.functions.notification.register.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: RandomData.shared.personId(),
-            token: 'abc'
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Person not found')));
-    });
-
-    it('person not signed in', async () => {
-        const result = await FirebaseApp.shared.functions.notification.register.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: FirebaseApp.shared.testTeam.persons[1].id,
-            token: 'abc'
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('unauthenticated', 'Person not signed in')));
-    });
-
-    it('should register notification', async () => {
-        await FirebaseApp.shared.functions.notification.register.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: FirebaseApp.shared.testTeam.persons[0].id,
-            token: 'abc'
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[0].id).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data.signInProperties !== null).toBeTrue();
-        expect(personSnapshot.data.signInProperties?.notificationProperties.tokens[NotificationProperties.TokenId.create('abc').value]).toBeEqual('abc');
-    });
-});

package/test/functions/notifcation/subscribe.test.ts

@@ -1,46 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-
-describe('NotificationSubscribeFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('fineTemplate-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('person not found', async () => {
-        const result = await FirebaseApp.shared.functions.notification.subscribe.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: RandomData.shared.personId(),
-            subscriptions: ['new-fine', 'fine-reminder']
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Person not found')));
-    });
-
-    it('person not signed in', async () => {
-        const result = await FirebaseApp.shared.functions.notification.subscribe.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: FirebaseApp.shared.testTeam.persons[1].id,
-            subscriptions: ['new-fine', 'fine-reminder']
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('unauthenticated', 'Person not signed in')));
-    });
-
-    it('should subscribe notification', async () => {
-        await FirebaseApp.shared.functions.notification.subscribe.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: FirebaseApp.shared.testTeam.persons[0].id,
-            subscriptions: ['new-fine', 'fine-reminder']
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[0].id).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data.signInProperties !== null).toBeTrue();
-        expect(personSnapshot.data.signInProperties?.notificationProperties.subscriptions).toBeEqual(['new-fine', 'fine-reminder']);
-    });
-});

package/test/functions/paypalMe/edit.test.ts

@@ -1,42 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-
-describe('PaypalMeEditFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('team-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('team not found', async () => {
-        await FirebaseApp.shared.firestore.team(FirebaseApp.shared.testTeam.id).remove();
-        const result = await FirebaseApp.shared.functions.paypalMe.edit.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            paypalMeLink: 'https://paypal.me/TeamPropertiesManager'
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Team not found')));
-    });
-
-    it('add and remove paypalMeLink', async () => {
-        await FirebaseApp.shared.functions.paypalMe.edit.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            paypalMeLink: 'paypal.me/my-link'
-        });
-        let teamSnapshot = await FirebaseApp.shared.firestore.team(FirebaseApp.shared.testTeam.id).snapshot();
-        expect(teamSnapshot.exists).toBeTrue();
-        expect(teamSnapshot.data.paypalMeLink).toBeEqual('paypal.me/my-link');
-
-        await FirebaseApp.shared.functions.paypalMe.edit.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            paypalMeLink: null
-        });
-        teamSnapshot = await FirebaseApp.shared.firestore.team(FirebaseApp.shared.testTeam.id).snapshot();
-        expect(teamSnapshot.exists).toBeTrue();
-        expect(teamSnapshot.data.paypalMeLink).toBeEqual(null);
-    });
-});

package/test/functions/person/add.test.ts

@@ -1,39 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-import { Person } from '../../../src/types';
-
-describe('PersonAddFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('person-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('person already exists', async () => {
-        const result = await FirebaseApp.shared.functions.person.add.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            id: FirebaseApp.shared.testTeam.persons[1].id,
-            properties: RandomData.shared.personPrivateProperties()
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('already-exists', 'Person already exists')));
-    });
-
-    it('should add person', async () => {
-        const personId = RandomData.shared.personId();
-        const personPrivateProperties = RandomData.shared.personPrivateProperties();
-        await FirebaseApp.shared.functions.person.add.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            id: personId,
-            properties: personPrivateProperties
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, personId).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data).toBeEqual(new Person(personId, personPrivateProperties).flatten);
-    });
-});

package/test/functions/person/delete.test.ts

@@ -1,41 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-
-describe('PersonDeleteFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('person-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('person not found', async () => {
-        const result = await FirebaseApp.shared.functions.person.delete.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            id: RandomData.shared.personId()
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Person not found')));
-    });
-
-    it('person is signed in', async () => {
-        const result = await FirebaseApp.shared.functions.person.delete.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            id: FirebaseApp.shared.testTeam.persons[0].id
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('failed-precondition', 'Person is signed in')));
-    });
-
-    it('should delete person', async () => {
-        await FirebaseApp.shared.functions.person.delete.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            id: FirebaseApp.shared.testTeam.persons[1].id
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[1].id).snapshot();
-        expect(personSnapshot.exists).toBeFalse();
-    });
-});

package/test/functions/person/update.test.ts

@@ -1,39 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-import { Person } from '../../../src/types';
-
-describe('PersonUpdateFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('person-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('person not found', async () => {
-        const result = await FirebaseApp.shared.functions.person.update.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            id: RandomData.shared.personId(),
-            properties: RandomData.shared.personPrivateProperties()
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'Person not found')));
-    });
-
-    it('should update person', async () => {
-        const personPrivateProperties = RandomData.shared.personPrivateProperties();
-        await FirebaseApp.shared.functions.person.update.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            id: FirebaseApp.shared.testTeam.persons[1].id,
-            properties: personPrivateProperties
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[1].id).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        const snapshotPerson = Person.builder.build(personSnapshot.data);
-        expect(personSnapshot.data).toBeEqual(new Person(FirebaseApp.shared.testTeam.persons[1].id, personPrivateProperties, snapshotPerson.fineIds, snapshotPerson.signInProperties).flatten);
-    });
-});

package/test/functions/team/new.test.ts

@@ -1,139 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-import { User, UserRole } from '../../../src/types';
-
-describe('TeamNewFunction', () => {
-
-    let userId: User.Id;
-
-    beforeEach(async () => {
-        userId = await FirebaseApp.shared.addTestTeam();
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('should throw an error if user is not authenticated', async () => {
-        await FirebaseApp.shared.auth.signOut();
-        const result = await FirebaseApp.shared.functions.team.new.executeWithResult({
-            id: RandomData.shared.teamId(),
-            name: RandomData.shared.teamName(),
-            paypalMeLink: null,
-            personId: RandomData.shared.personId(),
-            personProperties: RandomData.shared.personPrivateProperties()
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('permission-denied', 'User is not authenticated')));
-    });
-
-    it('should throw an error if team already exists', async () => {
-        const result = await FirebaseApp.shared.functions.team.new.executeWithResult({
-            id: FirebaseApp.shared.testTeam.id,
-            name: RandomData.shared.teamName(),
-            paypalMeLink: null,
-            personId: RandomData.shared.personId(),
-            personProperties: RandomData.shared.personPrivateProperties()
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('already-exists', 'Team already exists')));
-    });
-
-    it('should create a new team existing user', async () => {
-        const teamId = RandomData.shared.teamId();
-        const teamName = RandomData.shared.teamName();
-        const personId = RandomData.shared.personId();
-        const personPrivateProperties = RandomData.shared.personPrivateProperties();
-        const user = await FirebaseApp.shared.functions.team.new.execute({
-            id: teamId,
-            name: teamName,
-            paypalMeLink: null,
-            personId: personId,
-            personProperties: personPrivateProperties
-        });
-        expect(user.teams.has(teamId)).toBeTrue();
-        expect(user.teams.get(teamId)).toBeEqual(new User.TeamProperties(teamName, personId));
-        const userSnpapshot = await FirebaseApp.shared.firestore.user(userId).snapshot();
-        expect(userSnpapshot.exists).toBeTrue();
-        expect(teamId.guidString in userSnpapshot.data.teams).toBeTrue();
-        const userTeam = userSnpapshot.data.teams[teamId.guidString];
-        expect(userTeam).toBeEqual({
-            name: teamName,
-            personId: personId.guidString
-        });
-        const teamSnapshot = await FirebaseApp.shared.firestore.team(teamId).snapshot();
-        expect(teamSnapshot.exists).toBeTrue();
-        expect(teamSnapshot.data).toBeEqual({
-            id: teamId.guidString,
-            name: teamName,
-            paypalMeLink: null
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(teamId, personId).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data.signInProperties !== null).toBeTrue();
-        expect(personSnapshot.data).toBeEqual({
-            id: personId.guidString,
-            properties: personPrivateProperties.flatten,
-            fineIds: [],
-            signInProperties: {
-                userId: userId.value,
-                signInDate: personSnapshot.data.signInProperties!.signInDate,
-                notificationProperties: {
-                    tokens: {},
-                    subscriptions: []
-                },
-                roles: UserRole.all
-            }
-        });
-    });
-
-    it('should create a new team not exiting user', async () => {
-        const teamId = RandomData.shared.teamId();
-        const teamName = RandomData.shared.teamName();
-        const personId = RandomData.shared.personId();
-        const personPrivateProperties = RandomData.shared.personPrivateProperties();
-        await FirebaseApp.shared.firestore.user(userId).remove();
-        const user = await FirebaseApp.shared.functions.team.new.execute({
-            id: teamId,
-            name: teamName,
-            paypalMeLink: null,
-            personId: personId,
-            personProperties: personPrivateProperties
-        });
-        expect(user.teams.has(teamId)).toBeTrue();
-        expect(user.teams.get(teamId)).toBeEqual(new User.TeamProperties(teamName, personId));
-        const userSnpapshot = await FirebaseApp.shared.firestore.user(userId).snapshot();
-        expect(userSnpapshot.exists).toBeTrue();
-        expect(teamId.guidString in userSnpapshot.data.teams).toBeTrue();
-        const userTeam = userSnpapshot.data.teams[teamId.guidString];
-        expect(userTeam).toBeEqual({
-            name: teamName,
-            personId: personId.guidString
-        });
-        const teamSnapshot = await FirebaseApp.shared.firestore.team(teamId).snapshot();
-        expect(teamSnapshot.exists).toBeTrue();
-        expect(teamSnapshot.data).toBeEqual({
-            id: teamId.guidString,
-            name: teamName,
-            paypalMeLink: null
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(teamId, personId).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data.signInProperties !== null).toBeTrue();
-        expect(personSnapshot.data).toBeEqual({
-            id: personId.guidString,
-            properties: personPrivateProperties.flatten,
-            fineIds: [],
-            signInProperties: {
-                userId: userId.value,
-                signInDate: personSnapshot.data.signInProperties!.signInDate,
-                notificationProperties: {
-                    tokens: {},
-                    subscriptions: []
-                },
-                roles: UserRole.all
-            }
-        });
-    });
-});

package/test/functions/user/login.test.ts

@@ -1,37 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { User } from '../../../src/types';
-
-describe('UserLoginFunction', () => {
-
-    let userId: User.Id;
-
-    beforeEach(async () => {
-        userId = await FirebaseApp.shared.addTestTeam();
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('not signed in', async () => {
-        await FirebaseApp.shared.auth.signOut();
-        const result = await FirebaseApp.shared.functions.user.login.executeWithResult(null);
-        expect(result).toBeEqual(Result.failure(new FunctionsError('unauthenticated', 'User is not authenticated.')));
-    });
-
-    it('user not found', async () => {
-        await FirebaseApp.shared.auth.signOut();
-        await FirebaseApp.shared.auth.signIn('abc.def@ghi.jkl', 'password');
-        const result = await FirebaseApp.shared.functions.user.login.executeWithResult(null);
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'User not found.')));
-    });
-
-    it('login', async () => {
-        const user = await FirebaseApp.shared.functions.user.login.execute(null);
-        const userSnapshot = await FirebaseApp.shared.firestore.user(userId).snapshot();
-        expect(user).toBeEqual(User.builder.build(userSnapshot.data));
-    });
-});

package/test/functions/user/roleEdit.test.ts

@@ -1,47 +0,0 @@
-import { expect } from '@assertive-ts/core';
-import { FirebaseApp } from '../../FirebaseApp';
-import { Result } from '@stevenkellner/typescript-common-functionality';
-import { FunctionsError } from '@stevenkellner/firebase-function';
-import { RandomData } from '../../RandomData';
-
-describe('UserRoleEditFunction', () => {
-
-    beforeEach(async () => {
-        await FirebaseApp.shared.addTestTeam('team-manager');
-    });
-
-    afterEach(async () => {
-        await FirebaseApp.shared.firestore.clear();
-    });
-
-    it('remove team-manager role from user', async () => {
-        const result = await FirebaseApp.shared.functions.user.roleEdit.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: FirebaseApp.shared.testTeam.persons[0].id,
-            roles: []
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('unavailable', 'User cannot remove their own team-manager role')));
-    });
-
-    it('user does not exist', async () => {
-        const result = await FirebaseApp.shared.functions.user.roleEdit.executeWithResult({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: RandomData.shared.personId(),
-            roles: ['team-manager']
-        });
-        expect(result).toBeEqual(Result.failure(new FunctionsError('not-found', 'User does not exist')));
-    });
-
-    it('edit user roles', async () => {
-        await FirebaseApp.shared.functions.user.roleEdit.execute({
-            teamId: FirebaseApp.shared.testTeam.id,
-            personId: FirebaseApp.shared.testTeam.persons[0].id,
-            roles: ['team-manager', 'fine-manager', 'person-manager']
-        });
-        const personSnapshot = await FirebaseApp.shared.firestore.person(FirebaseApp.shared.testTeam.id, FirebaseApp.shared.testTeam.persons[0].id).snapshot();
-        expect(personSnapshot.exists).toBeTrue();
-        expect(personSnapshot.data.signInProperties === null).toBeFalse();
-        expect(personSnapshot.data.signInProperties!.roles.length).toBeEqual(3);
-        expect(personSnapshot.data.signInProperties!.roles).toContainAll('team-manager', 'fine-manager', 'person-manager');
-    });
-});