125 lines
6.0 KiB
Go
125 lines
6.0 KiB
Go
package main
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// The first stage's account, as the operator sets the setting `accounts` (ADR 0359 §5): its address and its server,
|
|
// never a credential; its password is the own secret mail-credential-mesh.
|
|
const stageOne = `{"accounts": {"mesh": {"kind": "imap", "address": "jschoubben@novox.be",
|
|
"incoming": {"host": "mail.novox.be", "port": 993, "security": "tls"}}}}`
|
|
|
|
func TestTheFirstStagesAccountIsReadAndItsSecretNamed(t *testing.T) {
|
|
got, err := ParseAccounts([]byte(stageOne))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 1 || got[0].Name != "mesh" || got[0].Kind != KindIMAP || got[0].SignInAs() != "jschoubben@novox.be" ||
|
|
got[0].Incoming.Address() != "mail.novox.be:993" || got[0].Secret() != "mail-credential-mesh" || got[0].Outgoing != nil {
|
|
t.Fatalf("%+v", got)
|
|
}
|
|
if p := SecretPath("/state", got[0]); p != "/state/mail-credential-mesh.secret" {
|
|
t.Fatalf("the secret is placed at %s", p)
|
|
}
|
|
}
|
|
|
|
// A second account of the kind imap on another server — Gmail with an app password, another member of the family —
|
|
// is configuration only: no code changes for it. Each account may also say its outgoing server, which mail_send
|
|
// uses to send through it (novox/hq ADR 0361 §1).
|
|
func TestASecondIMAPAccountIsConfigurationOnly(t *testing.T) {
|
|
got, err := ParseAccounts([]byte(`{"accounts": {
|
|
"mesh": {"kind": "imap", "address": "jschoubben@novox.be", "incoming": {"host": "mail.novox.be", "port": 993, "security": "tls"}},
|
|
"gmail": {"kind": "imap", "address": "someone@gmail.com", "incoming": {"host": "imap.gmail.com", "port": 993, "security": "tls"},
|
|
"outgoing": {"host": "smtp.gmail.com", "port": 465, "security": "tls"}, "folders": ["[Gmail]/Sent Mail"]}}}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 2 || got[0].Name != "gmail" || got[0].Secret() != "mail-credential-gmail" || got[0].Outgoing.Address() != "smtp.gmail.com:465" ||
|
|
!reflect.DeepEqual(got[0].Folders, []string{"[Gmail]/Sent Mail"}) {
|
|
t.Fatalf("%+v", got)
|
|
}
|
|
}
|
|
|
|
func TestAnAccountThatCannotBeWatchedRefusesTheSetting(t *testing.T) {
|
|
for name, raw := range map[string]string{
|
|
"a later kind": `{"accounts": {"work": {"kind": "graph", "address": "a@b.c", "incoming": {"host": "h", "port": 1, "security": "tls"}}}}`,
|
|
"no encryption": `{"accounts": {"x": {"kind": "imap", "address": "a@b.c", "incoming": {"host": "h", "port": 143, "security": "none"}}}}`,
|
|
"a name with a dot": `{"accounts": {"my.box": {"kind": "imap", "address": "a@b.c", "incoming": {"host": "h", "port": 993, "security": "tls"}}}}`,
|
|
"a password in it": `{"accounts": {"x": {"kind": "imap", "address": "a@b.c", "password": "p", "incoming": {"host": "h", "port": 993, "security": "tls"}}}}`,
|
|
"no address": `{"accounts": {"x": {"kind": "imap", "incoming": {"host": "h", "port": 993, "security": "tls"}}}}`,
|
|
"the inbox listed": `{"accounts": {"x": {"kind": "imap", "address": "a@b.c", "folders": ["INBOX"], "incoming": {"host": "h", "port": 993, "security": "tls"}}}}`,
|
|
"a bad outgoing one": `{"accounts": {"x": {"kind": "imap", "address": "a@b.c", "incoming": {"host": "h", "port": 993, "security": "tls"}, "outgoing": {"host": "", "port": 465, "security": "tls"}}}}`,
|
|
} {
|
|
if _, err := ParseAccounts([]byte(raw)); err == nil {
|
|
t.Errorf("%s: accepted", name)
|
|
}
|
|
}
|
|
if got, err := ParseAccounts([]byte(`{"accounts": {}}`)); err != nil || len(got) != 0 {
|
|
t.Fatalf("the manifest's default: %v %v", got, err)
|
|
}
|
|
}
|
|
|
|
// Grants (ADR 0359 §4): nobody by default; a module's name grants it wherever it runs; a module on one machine, or a
|
|
// person, by its full name; never the unproven, never by a wildcard, never one account for another.
|
|
func TestGrantsAreByAccountAndByProvenCaller(t *testing.T) {
|
|
g := Grants{"mesh": {"triage", "novox.desk", "person.jochen", "*"}}
|
|
for caller, want := range map[string]bool{
|
|
"novox.triage": true, "shanks.triage": true, "novox.desk": true, "g14.desk": false, "person.jochen": true,
|
|
"person.triage": false, "novox.other": false, Unproven: false, "": false, "novox.*": false,
|
|
} {
|
|
if got := g.Allows(caller, "mesh"); got != want {
|
|
t.Errorf("%s: %v", caller, got)
|
|
}
|
|
}
|
|
if g.Allows("novox.triage", "gmail") || (Grants{}).Allows("novox.triage", "mesh") {
|
|
t.Fatal("a grant reached an account it does not name")
|
|
}
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "grants.json")
|
|
_ = os.WriteFile(path, []byte(`{"grants": {"mesh": ["triage"]}}`), 0o600)
|
|
read, err := ReadGrants(path)
|
|
if err != nil || !read.Allows("novox.triage", "mesh") {
|
|
t.Fatalf("%v %v", read, err)
|
|
}
|
|
_ = os.WriteFile(path, []byte(`{"grants": {"mesh": "triage"}}`), 0o600)
|
|
if read, err := ReadGrants(path); err == nil || len(read) != 0 {
|
|
t.Fatal("a grants setting it cannot read granted something")
|
|
}
|
|
}
|
|
|
|
// Whether a password was given is read from the file's presence and size alone (issue 733): an empty file is not
|
|
// given, a file the judge cannot read is still given, and the password is never read to say so.
|
|
func TestASecretIsGivenByItsFileNotByReadingIt(t *testing.T) {
|
|
dir := t.TempDir()
|
|
a := testAccount()
|
|
if SecretGiven(dir, a) {
|
|
t.Fatal("given before anything was written")
|
|
}
|
|
_ = os.WriteFile(SecretPath(dir, a), nil, 0o600)
|
|
if SecretGiven(dir, a) {
|
|
t.Fatal("an empty file is a password")
|
|
}
|
|
_ = os.WriteFile(SecretPath(dir, a), []byte("pw\n"), 0o600)
|
|
if pw, given, _ := ReadSecret(dir, a); !given || pw != "pw" || strings.Contains(pw, "\n") {
|
|
t.Fatalf("%q %v", pw, given)
|
|
}
|
|
// Unreadable to the judge, as a secret owned by root is to the watch: still given.
|
|
if err := os.Chmod(SecretPath(dir, a), 0); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !SecretGiven(dir, a) {
|
|
t.Fatal("a password the judge cannot read is said not given")
|
|
}
|
|
src, _ := os.ReadFile("config.go")
|
|
body := string(src)
|
|
body = body[strings.Index(body, "func SecretGiven("):]
|
|
body = body[:strings.Index(body, "\n}\n")]
|
|
if strings.Contains(body, "ReadSecret") || strings.Contains(body, "ReadFile") || strings.Contains(body, "os.Open") {
|
|
t.Fatalf("SecretGiven reads the password:\n%s", body)
|
|
}
|
|
}
|