Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-auth

Source of release 0.6.1

0.6.1 / tests / check.lucb

import interop
from luce_auth import auth
from luce_prism import prism

pub func main(arguments: str[]) -> i32!:
    assert(arguments.length == 3)
    let authority = try auth.Authority.open(arguments[1], "secret", test_only = true)
    defer authority.release()
    try authority.value().bootstrap("alice", "correct horse")
    var again = false
    authority.value().bootstrap("bob", "x") catch failure:
        assert(failure.code == prism.conflict)
        again = true
    assert(again)
    let token_value = try authority.value().login("alice", "correct horse")
    defer token_value.release()
    let token = try token_value.value().text_at()
    let who = try authority.value().verify(token)
    defer who.release()
    assert(try who.value().text_at() == "alice")
    var bad = false
    let wrong: interop.Reference[prism.Value]? = authority.value().login("alice", "wrong") catch failure:
        assert(failure.code == prism.invalid)
        bad = true
        recover none
    if let extra = wrong:
        extra.release()
        assert(false)
    assert(bad)
    let invite_value = try authority.value().invite()
    defer invite_value.release()
    let code = try invite_value.value().text_at()
    try authority.value().accept(code, "bob", "bob-pass")
    var reused = false
    authority.value().accept(code, "carol", "x") catch failure:
        assert(failure.code == prism.invalid)
        reused = true
    assert(reused)
    let bob = try authority.value().login("bob", "bob-pass")
    defer bob.release()
    try authority.value().revoke(try bob.value().text_at())
    var gone = false
    let missing: interop.Reference[prism.Value]? = authority.value().verify(try bob.value().text_at()) catch failure:
        assert(failure.code == prism.missing)
        gone = true
        recover none
    if let extra = missing:
        extra.release()
        assert(false)
    assert(gone)
    let store = try prism.Store.open(arguments[2], token = "secret")
    defer store.release()
    let attached = try auth.Authority.attach(store.value(), test_only = true)
    defer attached.release()
    let before = try store.value().snapshot()
    defer before.release()
    let revision = try before.value().revision()
    let another = try auth.Authority.attach(store.value(), test_only = true)
    defer another.release()
    let after = try store.value().snapshot()
    defer after.release()
    assert(try after.value().revision() == revision)
    try attached.value().bootstrap("carol", "carol-pass")
    let carol = try attached.value().login("carol", "carol-pass")
    defer carol.release()
    let carol_name = try attached.value().verify(try carol.value().text_at())
    defer carol_name.release()
    assert(try carol_name.value().text_at() == "carol")
    print("PASS luce-auth bootstrap, invite, login, revoke")
    return 0