macltok

# drives macltok in a headless firefox worker against a throwaway continuwuity

# run from the web devshell, `nix develop .#web -c nu harness/web/run.nu`

const crate = path self .

const root = path self ../..

const username = "harness"

const password = "harness-password"

# the shared build wrapper sets CARGO_TARGET_DIR, the nix sandbox does not

def target [] { $env.CARGO_TARGET_DIR? | default ($root | path join target) }

def scratch [] { target | path join harness }

def start-homeserver [] {

    let dir = scratch

    rm -rf $dir

    mkdir $dir

    let port = 6167

    let config = $dir | path join homeserver.toml

    let log = $dir | path join homeserver.log

    {

        global: {

            server_name: "localhost"

            database_path: ($dir | path join db)

            address: ["127.0.0.1"]

            port: $port

            allow_federation: false

            new_user_displayname_suffix: ""

        }

    } | to toml | save $config

    # the first account otherwise needs a one-time token that is only ever printed to the log

    let create = $"users create-user ($username) ($password)"

    let pid = ^bash -c 'conduwuit -c "$1" --execute "$2" > "$3" 2>&1 & echo $!' _ $config $create $log | str trim

    let url = $'http://127.0.0.1:($port)'

    for _ in 1..100 {

        if (try { login $url | ignore; true } catch { false }) {

            return { pid: $pid, url: $url }

        }

        sleep 100ms

    }

    try { stop $pid }

    print (open --raw $log | lines | last 20 | str join "\n")

    error make { msg: "homeserver did not come up" }

}

def login [url: string] {

    let body = { type: "m.login.password", identifier: { type: "m.id.user", user: $username }, password: $password }

    http post --content-type application/json $'($url)/_matrix/client/v3/login' $body

}

def seed [url: string] {

    let auth = [Authorization $'Bearer ((login $url).access_token)']

    http post --headers $auth --content-type application/json $'($url)/_matrix/client/v3/createRoom' { name: "harness" } | ignore

}

def stop [pid: string] {

    ^kill -9 $pid

}

def main [] {

    let server = start-homeserver

    let result = try {

        let versions = http get $'($server.url)/_matrix/client/versions'

        if not ($versions.unstable_features | get -o 'org.matrix.simplified_msc3575' | default false) {

            error make { msg: "homeserver does not advertise simplified sliding sync" }

        }

        seed $server.url

        cd $crate

        with-env {

            MACLTOK_HOMESERVER: $server.url

            MACLTOK_USERNAME: $username

            MACLTOK_PASSWORD: $password

            GECKODRIVER: (which geckodriver | get 0.path)

            WASM_BINDGEN_TEST_TIMEOUT: "180"

        } {

            ^cargo test --target wasm32-unknown-unknown --test worker

        }

        null

    } catch {|error| $error }

    stop $server.pid

    if $result != null {

        print $'homeserver log at (scratch)/homeserver.log'

        error make { msg: $result.msg }

    }

}

# release build of the same slice, sized raw, after wasm-opt, and compressed

def "main size" [] {

    let target = target

    let out = scratch | path join size

    rm -rf $out

    mkdir $out

    cd $crate

    ^cargo build --release --lib --target wasm32-unknown-unknown

    ^wasm-bindgen --target web --out-dir $out ($target | path join wasm32-unknown-unknown release macltok_web.wasm)

    let raw = $out | path join macltok_web_bg.wasm

    let opt = $out | path join macltok_web_opt.wasm

    ^wasm-opt -Oz --enable-bulk-memory --enable-nontrapping-float-to-int --enable-sign-ext --enable-mutable-globals --enable-reference-types --enable-multivalue -o $opt $raw

    ^gzip -9 -k $opt

    ^brotli -q 11 -k $opt

    [$raw $opt $'($opt).gz' $'($opt).br'] | each {|file| { file: ($file | path basename), size: (ls $file | get 0.size) } }

}