livewiretest

func GeneratedIsCurrent ¶

func GeneratedIsCurrent(tb testing.TB, registry *livewire.Registry, options *generate.Options)

GeneratedIsCurrent renders every artifact of the registry in memory, as generate.Write would write it with options (TypeScript, OpenAPI, the Go client and the CLI, whichever the options name), and fails the test for every committed file that is missing or differs, with the lines that differ (D23). Pass the options the application's generator command passes, with paths relative to the test's working directory, the package directory.

application, err := startNotes(brokenBy{})
if err != nil {
	panic(err)
}
defer application.close()
directory, err := os.MkdirTemp("", "livewiretest-example-")
if err != nil {
	panic(err)
}
defer func() { _ = os.RemoveAll(directory) }()
// The options the application's generator command passes, relative to the test's package.
options := &generate.Options{TypeScriptDirectory: filepath.Join(directory, "web", "src", "api")}
if err := generate.Write(application.Engine.Registry(), options); err != nil {
	panic(err)
}

fmt.Println(verdict(gateFailures(func(t testing.TB) {
	livewiretest.GeneratedIsCurrent(t, application.Engine.Registry(), options)
})))

Output:
passed

func GeneratedIsCurrentStrict ¶

func GeneratedIsCurrentStrict(tb testing.TB, registry *livewire.Registry, options *generate.Options)

GeneratedIsCurrentStrict is GeneratedIsCurrent for an application whose output directories belong to the generator: it also fails on every file below the TypeScript, Go client and CLI directories that the registry no longer generates, such as the client of a removed declaration's leftover file. An application that keeps its own files there uses GeneratedIsCurrent.

func Parity ¶

func Parity(tb testing.TB, options *ParityOptions)

Parity fails the test for every read of the registry whose REST body differs from its socket payload byte for byte (D23): the answer of a socket query, and for a live read the first push of a subscribe too, each against the REST body of the same read as the same identity, through the application's Handler. It covers every read kind of every declaration (a resource's list, item, distinct and history reads, a list's and an object's read, and the presence reads when the engine serves them); a read that needs parameters and has no Read fails the gate, as does a read the application answers with anything but 200.

application, err := startNotes(brokenBy{})
if err != nil {
	panic(err)
}
defer application.close()

fmt.Println(verdict(gateFailures(func(t testing.TB) {
	livewiretest.Parity(t, &livewiretest.ParityOptions{
		Application:  application.Application,
		Authenticate: as("alice"),
		Reads: []livewiretest.Read{
			{Target: "notes.item", Parameters: map[string]string{"id": application.firstNote("north")}},
			{Target: "notes.history", Parameters: map[string]string{"id": application.firstNote("north")}},
			{Target: "notes.distinct", Parameters: map[string]string{"field": "title"}},
		},
	})
})))

Output:
passed

func Stale ¶

func Stale(tb testing.TB, options *StaleOptions)

Stale subscribes to every live read of the registry (presence reads aside, whose table is the library's own) and runs the writes one after another (D23). After each it reads every subscribed read over REST and fails the test, naming the declaration, for every subscription whose state does not reach that REST body within the timeout: a write the subscription should have re-run on and did not, because the declaration does not list the table the write changed, or the table sends no notification (TriggerSQL missing), or the change feed does not reach the engine. A write to a declared table that changes no live read of a declaration listing it fails too: it proves nothing about that table.

What it cannot catch: a table no Write writes. It requires a write for every declared table, but no gate can discover a table a loader reads without declaring it; give the writes of every table the loaders read, declared or not, and Stale catches the undeclared ones. It also checks only what the fixture identity reads, through the reads it is given.

application, err := startNotes(brokenBy{})
if err != nil {
	panic(err)
}
defer application.close()

fmt.Println(verdict(gateFailures(func(t testing.TB) {
	livewiretest.Stale(t, &livewiretest.StaleOptions{
		Application:  application.Application,
		Authenticate: as("alice"),
		Reads: []livewiretest.Read{
			{Target: "notes.item", Parameters: map[string]string{"id": application.firstNote("north")}},
			{Target: "notes.history", Parameters: map[string]string{"id": application.firstNote("north")}},
			{Target: "notes.distinct", Parameters: map[string]string{"field": "title"}},
		},
		Writes: []livewiretest.Write{application.addNote("north", "second"), application.addTag("north", "later")},
	})
})))

Output:
passed

func TenantIsolation ¶

func TenantIsolation(tb testing.TB, options *TenantIsolationOptions)

TenantIsolation reads every filterable resource of the registry as both tenants over REST (D42, DAT-017) and fails the test when anything of one tenant reaches the other. It lists every row of each tenant, paging until a page comes back short (past a CountCap), and keys each row by the resource's item key (its "id" without an item read); a row without a key fails, as nothing could be checked about it. Then, for each tenant, it fails on:

• a listed row whose key is one of the other tenant's;
• an item read of one of its own rows that answers another row, and an item read of any row of the other tenant that answers anything but 404 or 403;
• a version in the history of one of its own rows that belongs to another row, and a history read of any row of the other tenant that answers anything but 404 or 403;
• an export that writes no key column, or a row whose key is not one of its own;
• a distinct read of a filterable field whose values or counts differ from its own rows'.

A resource of which a tenant reads no row fails too: the gate needs rows of both tenants.

application, err := startNotes(brokenBy{})
if err != nil {
	panic(err)
}
defer application.close()

fmt.Println(verdict(gateFailures(func(t testing.TB) {
	livewiretest.TenantIsolation(t, &livewiretest.TenantIsolationOptions{
		Application: application.Application,
		Tenants:     [2]livewiretest.Tenant{{Name: "north", Authenticate: as("alice")}, {Name: "south", Authenticate: as("bob")}},
	})
})))

Output:
passed