authtest

type Fake ¶

type Fake struct {
	// Users is where the fake finds people. It is exported so that a consumer
	// invites somebody through the same interface the real module takes.
	Users contracts.Users

	// Operator are the permissions the operator's own administrator is granted
	// by name, the same list the application hands the real module.
	Operator []string

	// Notify is where the in-application notice goes. It never carries the
	// link, for the reason the real service's does not: a notification is an
	// ordinary row and a token in one is a live credential in a table.
	Notify contracts.Notifier

	// Mailer is where the link itself goes, and the only place it goes. A fake
	// with none writes no token and sends nothing, exactly as the real service
	// does.
	Mailer contracts.Mailer
	// contains filtered or unexported fields
}

Fake is contracts.Service over two maps: the same rules, no database, no transaction. A consumer that wants to test what it does for a signed-in caller takes one of these instead of a Postgres.

It keeps the real limiter and hashes with the real argon2id, because both are part of what Login promises rather than of how it stores things. What it cannot be is what row-level security is: there is one tenant here, so "a session from another tenant is invisible" is a claim only the real service can be held to, and internal/service_test.go holds it.

func NewFake(users contracts.Users) *Fake

func (f *Fake) ChangePassword(ctx context.Context, tx db.Tx[db.Tenant], userID, keep uuid.UUID, current, next string) error

func (f *Fake) Forget(_ context.Context, _ db.Tx[db.Tenant], _ string) error

func (f *Fake) Grant(name string, permissions ...string)

func (f *Fake) Identify(ctx context.Context, tx db.Tx[db.Tenant], id uuid.UUID, from contracts.Client) (*contracts.Identity, error)

func (f *Fake) Login(ctx context.Context, tx db.Tx[db.Tenant], email, password string, from contracts.Client) (*contracts.Session, *contracts.Identity, error)

func (f *Fake) Logout(_ context.Context, _ db.Tx[db.Tenant], id uuid.UUID) error

func (f *Fake) MayAsk(ctx context.Context, ip string) bool

func (f *Fake) MayRedeem(ctx context.Context, ip string) bool

func (f *Fake) Offer(ctx context.Context, tx db.Tx[db.Tenant], userID uuid.UUID) error

func (f *Fake) Open(ctx context.Context, tx db.Tx[db.Tenant], id uuid.UUID, from contracts.Client) (*contracts.Session, *contracts.Identity, error)

func (f *Fake) Permissions(_ context.Context, _ db.Tx[db.Tenant], roles []string) ([]string, error)

func (f *Fake) Precheck(ctx context.Context, email, ip string) contracts.Verdict

func (f *Fake) Published() []string

func (f *Fake) Purge(_ context.Context, _ db.Tx[db.Tenant]) (int64, error)

func (f *Fake) Reissue(ctx context.Context, tx db.Tx[db.Tenant], email string) error

func (f *Fake) Reset(ctx context.Context, tx db.Tx[db.Tenant], token, password string) error

func (f *Fake) RevokeSessions(_ context.Context, _ db.Tx[db.Tenant], userID, except uuid.UUID) error

func (f *Fake) Roles(_ context.Context, _ db.Tx[db.Tenant]) ([]*contracts.Role, error)

func (f *Fake) SeedRoles(_ context.Context, _ db.Tx[db.System], _ uuid.UUID, operator bool) error

func (f *Fake) SessionsOf(user uuid.UUID) int

func (f *Fake) SetRole(_ context.Context, tx db.Tx[db.Tenant], name string, permissions []string, declared []tenancy.Grant) (*contracts.Role, error)

type Fixture ¶

type Fixture struct {
	Ctx     context.Context
	Tx      db.Tx[db.Tenant]
	Service contracts.Service
	// User creates a user and returns their id. An empty password makes
	// somebody who has been invited and cannot sign in yet.
	User func(email, password string, roles ...string) uuid.UUID
	// Role grants permissions to a role name in this tenant.
	Role func(name string, permissions ...string)
	// Published is the names of the events published so far, in order.
	Published func() []string
	// Sent is every notice the implementation asked to be delivered, in order.
	// A case reads one to check what it does not carry.
	Sent func() []notificationcontracts.Notice
	// Mailed is every message the implementation handed a mail server, in
	// order. A case reads the link out of one to follow it, and it is the only
	// place it can be read — which is the property, not an inconvenience.
	Mailed func() []notificationcontracts.Message
	// Sessions reports how many sessions this user has, which is how a case
	// says "and the others ended" without knowing how they are stored.
	Sessions func(user uuid.UUID) int
}

Fixture is one case's world. The tenant already has the two roles SeedRoles installs, because that is what the tenant module's create hook does and every tenant that exists has been through it.

type Harness ¶

type Harness func(t *testing.T, run func(Fixture))

Harness builds one Fixture and calls run with it.

type Host ¶

type Host string

Host is a contracts.Hosts that answers one name, which is what a mailed link is built on.

func (h Host) PublicHost(context.Context, db.Tx[db.Tenant]) (string, error)

type Issuer ¶

type Issuer struct {
	*httptest.Server
	// contains filtered or unexported fields
}

Issuer is an OpenID Connect provider a test can sign in against: discovery, a JWKS, and a token endpoint that returns a signed id token for a code the test handed out.

There is no authorization endpoint, because a browser is the thing that would use it: a test follows the redirect itself, reads the state out of it, and calls the callback with a code it registered here. That is the whole round trip the application takes part in.

func NewIssuer(t interface {
	Fatalf(string, ...any)
	Cleanup(func())
},
) *Issuer

func (i *Issuer) Issue(code, email string, verified bool, audience, nonce string)

type Mailbox ¶

type Mailbox struct {
	// contains filtered or unexported fields
}

Mailbox is a contracts.Mailer that records instead of sending, which is where a conformance case reads the link an implementation mailed.

It is the only place a case can read it, and that is the property under test: the token is in the message and in no row anywhere. See internal.Service.offer.

func (m *Mailbox) Send(_ context.Context, msg notificationcontracts.Message) error

func (m *Mailbox) Sent() []notificationcontracts.Message

type Notices ¶

type Notices struct {
	// contains filtered or unexported fields
}

Notices is a contracts.Notifier that records instead of sending, so a conformance case can read the link an implementation would have mailed.

It is here rather than in each harness because both of them need it and the cases below read what it holds: the suite's claim is that a reset link is issued and works once, and a recorder is the only way to say that without a mail server.

func (n *Notices) Notify(_ context.Context, _ db.Tx[db.Tenant], notice notificationcontracts.Notice) (*notificationcontracts.Notification, error)

func (n *Notices) Sent() []notificationcontracts.Notice