Privatae
88 lines
3.4 KiB
Go
88 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// The owner's agent reads the switch list, the doctor and the device's asks
|
|
// from the machine's bastion over its socket; a read the bastion answers but
|
|
// cannot build comes back as that failure, not as a refusal with the
|
|
// administrator's command (the administrator would be told the same).
|
|
func TestTheSliceThreeReadsGoThroughTheLane(t *testing.T) {
|
|
askFlowWorld(t)
|
|
laneOwner(t, laneTestUID)
|
|
laneSock(t)
|
|
prevSys, prevLatest, prevSandbox := systemInstalled, doctorLatest, doctorSandbox
|
|
t.Cleanup(func() { systemInstalled, doctorLatest, doctorSandbox = prevSys, prevLatest, prevSandbox })
|
|
systemInstalled = func() bool { return true }
|
|
doctorLatest = func() string { return "" }
|
|
doctorSandbox = func() (bool, string) { return true, "" }
|
|
out := captureStdout(t)
|
|
|
|
if err := cmdSwitch([]string{"--list", "--json"}); err != nil {
|
|
t.Fatalf("switch --list --json: %v", err)
|
|
}
|
|
var sw switchesRead
|
|
if err := json.Unmarshal([]byte(printedSince(out, 0, "}\n")), &sw); err != nil {
|
|
t.Fatalf("switch --list --json printed %q (%v)", out(), err)
|
|
}
|
|
|
|
before := len(out())
|
|
err := cmdDoctor([]string{"--json"})
|
|
var q quietExit
|
|
if err != nil && !errors.As(err, &q) {
|
|
t.Fatalf("doctor through the lane: %v", err)
|
|
}
|
|
var d doctorRead
|
|
if err := json.Unmarshal([]byte(printedSince(out, before, "}\n")), &d); err != nil || len(d.Checks) == 0 {
|
|
t.Fatalf("doctor --json printed %q (%v)", out()[before:], err)
|
|
}
|
|
if c, ok := doctorCheckNamed(d, "owner"); !ok || !c.OK {
|
|
t.Errorf("the machine's doctor, read by its owner, does not find the owner: %+v", d.Checks)
|
|
}
|
|
|
|
p, err := deviceShownPath()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := cmdDeviceApprovals(nil); err != nil {
|
|
t.Fatalf("device-approvals through the lane: %v", err)
|
|
}
|
|
if _, err := os.Stat(p); err == nil {
|
|
t.Error("device-approvals read through the lane recorded what it printed as shown")
|
|
}
|
|
|
|
// MUTATION: drop `r.Failed = true` in serveRead. RESULT: red, the error
|
|
// carries the administrator's command.
|
|
err = cmdOpsList("", true)
|
|
var le *laneError
|
|
if err == nil || errors.As(err, &le) || strings.Contains(err.Error(), "As the administrator") {
|
|
t.Errorf("ops with nothing paired, through the lane: %v", err)
|
|
}
|
|
}
|
|
|
|
// `switch --list` passes the guard beside the system unit, as status does;
|
|
// `switch` does too since the owner's account switches through the lane
|
|
// (owneracts.go), and on Windows as well since the ask pipe.
|
|
func TestTheGuardLetsSwitchListThroughAndNotSwitch(t *testing.T) {
|
|
prevArgs, prevUnit, prevAuth := os.Args, linuxSystemUnitPresent, systemService.authority
|
|
t.Cleanup(func() { os.Args, linuxSystemUnitPresent, systemService.authority = prevArgs, prevUnit, prevAuth })
|
|
linuxSystemUnitPresent = func() bool { return true }
|
|
systemService.authority = false
|
|
os.Args = []string{"privatae-bastion", "switch", "--list", "--json"}
|
|
if err := guardServiceFork("switch"); err != nil {
|
|
t.Errorf("switch --list beside the system unit: %v", err)
|
|
}
|
|
os.Args = []string{"privatae-bastion", "switch", "box", "ops", "off"}
|
|
if err := guardServiceFork("switch"); err != nil {
|
|
t.Errorf("switch from the owner's account beside the system unit, before the lane could decide: %v", err)
|
|
}
|
|
if err := serviceGuard("windows", serviceGuardKey("switch", os.Args), true, false); err != nil {
|
|
t.Errorf("switch from the owner's account beside a Windows service, before the ask pipe could decide: %v", err)
|
|
}
|
|
}
|