zitadel/acceptance/tests/user.ts

import fetch from "node-fetch";
import {Page} from "@playwright/test";
import {registerWithPasskey} from "./register";
import {loginWithPasskey, loginWithPassword} from "./login";
import {changePassword} from "./password";

export interface userProps {
    email: string;
    firstName: string;
    lastName: string;
    organization: string;
    password: string;
}

class User {
    private readonly props: userProps;
    private user: string;

    constructor(userProps: userProps) {
        this.props = userProps;
    }

    async ensure(page: Page) {
        await this.remove()

        const body = {
            username: this.props.email,
            organization: {
                orgId: this.props.organization
            },
            profile: {
                givenName: this.props.firstName,
                familyName: this.props.lastName,
            },
            email: {
                email: this.props.email,
                isVerified: true,
            },
            password: {
                password: this.props.password!,
            }
        }

        const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/human", {
            method: 'POST',
            body: JSON.stringify(body),
            headers: {
                'Content-Type': 'application/json',
                'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
            }
        });
        if (response.statusCode >= 400 && response.statusCode != 409) {
            const error = 'HTTP Error: ' + response.statusCode + ' - ' + response.statusMessage;
            console.error(error);
            throw new Error(error);
        }
        return
    }

    async remove() {
        const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/" + this.userId(), {
            method: 'DELETE',
            headers: {
                'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
            }
        });
        if (response.statusCode >= 400 && response.statusCode != 404) {
            const error = 'HTTP Error: ' + response.statusCode + ' - ' + response.statusMessage;
            console.error(error);
            throw new Error(error);
        }
        return
    }

    public setUserId(userId: string) {
        this.user = userId
    }

    public userId() {
        return this.user;
    }

    public username() {
        return this.props.email;
    }

    public password() {
        return this.props.password;
    }

    public firstname() {
        return this.props.firstName
    }

    public lastname() {
        return this.props.lastName
    }

    public fullName() {
        return this.props.firstName + " " + this.props.lastName
    }

    public async login(page: Page) {
        await loginWithPassword(page, this.username(), this.password())
    }

    public async changePassword(page: Page, password: string) {
        await loginWithPassword(page, this.username(), this.password())
        await changePassword(page, this.username(), password)
        this.props.password = password
    }
}

export class PasswordUser extends User {
}

enum OtpType {
    time = "time-based",
    sms = "sms",
    email = "email",
}

export interface otpUserProps {
    email: string;
    firstName: string;
    lastName: string;
    organization: string;
    type: OtpType,
}

export class PasswordUserWithOTP extends User {
    private type: OtpType
    private code: string

    constructor(props: otpUserProps) {
        super({
            email: props.email,
            firstName: props.firstName,
            lastName: props.lastName,
            organization: props.organization,
            password: ""
        })
        this.type = props.type
    }

    async ensure(page: Page) {
        await super.ensure(page)

        const body = {
            username: this.props.email,
            organization: {
                orgId: this.props.organization
            },
            profile: {
                givenName: this.props.firstName,
                familyName: this.props.lastName,
            },
            email: {
                email: this.props.email,
                isVerified: true,
            },
            password: {
                password: this.props.password!,
            }
        }

        const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/human", {
            method: 'POST',
            body: JSON.stringify(body),
            headers: {
                'Content-Type': 'application/json',
                'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
            }
        });
        if (response.statusCode >= 400 && response.statusCode != 409) {
            const error = 'HTTP Error: ' + response.statusCode + ' - ' + response.statusMessage;
            console.error(error);
            throw new Error(error);
        }
        return
    }
}

export interface passkeyUserProps {
    email: string;
    firstName: string;
    lastName: string;
    organization: string;
}

export class PasskeyUser extends User {
    constructor(props: passkeyUserProps) {
        super({
            email: props.email,
            firstName: props.firstName,
            lastName: props.lastName,
            organization: props.organization,
            password: ""
        })
    }

    public async ensure(page: Page) {
        await this.remove()
        await registerWithPasskey(page, this.firstname(), this.lastname(), this.username())
    }

    public async login(page: Page) {
        await loginWithPasskey(page, this.username())
    }

    public async remove() {
        const resp = await getUserByUsername(this.username())
        if (!resp || !resp.result || !resp.result[0]) {
            return
        }
        this.setUserId(resp.result[0].userId)
        await super.remove()
    }
}

async function getUserByUsername(username: string) {
    const listUsersBody = {
        queries: [{
            userNameQuery: {
                userName: username,
            }
        }]
    }
    const jsonBody = JSON.stringify(listUsersBody)
    const registerResponse = await fetch(process.env.ZITADEL_API_URL! + "/v2/users", {
        method: 'POST',
        body: jsonBody,
        headers: {
            'Content-Type': 'application/json',
            'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
        }
    });
    if (registerResponse.statusCode >= 400) {
        const error = 'HTTP Error: ' + registerResponse.statusCode + ' - ' + registerResponse.statusMessage;
        console.error(error);
        throw new Error(error);
    }
    const respJson = await registerResponse.json()
    return respJson
}