mirror of
https://blitiri.com.ar/repos/chasquid
synced 2025-12-16 14:27:01 +00:00
0e29fe4ad8
Today, aliases parsing is too lax, silently ignoring most kinds of invalid lines. That behaviour can cause a lot of confusion when users think the aliases are being parsed, and also cause problems when extending the syntax. This patch fixes that problem by making aliases parsing return errors on the invalid lines. Unfortunately this will cause some previously-accepted files to now be rejected, but it should be quite visible.
769 lines
21 KiB
Go
769 lines
21 KiB
Go
package aliases
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"os"
|
|
"os/exec"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"blitiri.com.ar/go/chasquid/internal/trace"
|
|
)
|
|
|
|
type Cases []struct {
|
|
addr string
|
|
expect []Recipient
|
|
err error
|
|
}
|
|
|
|
func (cases Cases) check(t *testing.T, r *Resolver) {
|
|
t.Helper()
|
|
tr := trace.New("test", "check")
|
|
defer tr.Finish()
|
|
|
|
for _, c := range cases {
|
|
got, err := r.Resolve(tr, c.addr)
|
|
if err != c.err {
|
|
t.Errorf("case %q: expected error %v, got %v",
|
|
c.addr, c.err, err)
|
|
}
|
|
if !reflect.DeepEqual(got, c.expect) {
|
|
t.Errorf("case %q: got %+v, expected %+v",
|
|
c.addr, got, c.expect)
|
|
}
|
|
}
|
|
}
|
|
|
|
func mustExist(t *testing.T, r *Resolver, addrs ...string) {
|
|
t.Helper()
|
|
tr := trace.New("test", "mustExist")
|
|
defer tr.Finish()
|
|
for _, addr := range addrs {
|
|
if ok := r.Exists(tr, addr); !ok {
|
|
t.Errorf("address %q does not exist, it should", addr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func mustNotExist(t *testing.T, r *Resolver, addrs ...string) {
|
|
t.Helper()
|
|
tr := trace.New("test", "mustNotExist")
|
|
defer tr.Finish()
|
|
for _, addr := range addrs {
|
|
if ok := r.Exists(tr, addr); ok {
|
|
t.Errorf("address %q exists, it should not", addr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func allUsersExist(tr *trace.Trace, user, domain string) (bool, error) {
|
|
return true, nil
|
|
}
|
|
|
|
func noUsersExist(tr *trace.Trace, user, domain string) (bool, error) {
|
|
return false, nil
|
|
}
|
|
|
|
func usersWithXDontExist(tr *trace.Trace, user, domain string) (bool, error) {
|
|
if strings.HasPrefix(user, "x") {
|
|
return false, nil
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
var errUserLookup = errors.New("test error errUserLookup")
|
|
|
|
func usersWithXErrorYDontExist(tr *trace.Trace, user, domain string) (bool, error) {
|
|
if strings.HasPrefix(user, "x") {
|
|
return false, errUserLookup
|
|
}
|
|
if strings.HasPrefix(user, "y") {
|
|
return false, nil
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func TestBasic(t *testing.T) {
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("localA")
|
|
resolver.AddDomain("localB")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"a@localA": {{"c@d", EMAIL}, {"e@localB", EMAIL}},
|
|
"e@localB": {{"cmd", PIPE}},
|
|
"cmd@localA": {{"x@y", EMAIL}},
|
|
}
|
|
|
|
cases := Cases{
|
|
{"a@localA", []Recipient{{"c@d", EMAIL}, {"cmd", PIPE}}, nil},
|
|
{"e@localB", []Recipient{{"cmd", PIPE}}, nil},
|
|
{"x@y", []Recipient{{"x@y", EMAIL}}, nil},
|
|
}
|
|
cases.check(t, resolver)
|
|
|
|
mustExist(t, resolver, "a@localA", "e@localB", "cmd@localA")
|
|
mustNotExist(t, resolver, "x@y")
|
|
}
|
|
|
|
func TestCatchAll(t *testing.T) {
|
|
resolver := NewResolver(usersWithXDontExist)
|
|
resolver.DropChars = "."
|
|
resolver.SuffixSep = "+"
|
|
resolver.AddDomain("dom")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"a@dom": {{"a@remote", EMAIL}},
|
|
"b@dom": {{"c@dom", EMAIL}},
|
|
"c@dom": {{"cmd", PIPE}},
|
|
"*@dom": {{"c@dom", EMAIL}},
|
|
}
|
|
|
|
cases := Cases{
|
|
{"a@dom", []Recipient{{"a@remote", EMAIL}}, nil},
|
|
{"a+z@dom", []Recipient{{"a@remote", EMAIL}}, nil},
|
|
{"a.@dom", []Recipient{{"a@remote", EMAIL}}, nil},
|
|
{"b@dom", []Recipient{{"cmd", PIPE}}, nil},
|
|
{"c@dom", []Recipient{{"cmd", PIPE}}, nil},
|
|
{"x@dom", []Recipient{{"cmd", PIPE}}, nil},
|
|
|
|
// Remote should be returned as-is regardless.
|
|
{"a@remote", []Recipient{{"a@remote", EMAIL}}, nil},
|
|
{"x@remote", []Recipient{{"x@remote", EMAIL}}, nil},
|
|
}
|
|
cases.check(t, resolver)
|
|
|
|
mustExist(t, resolver,
|
|
// Exist as users.
|
|
"a@dom", "b@dom", "c@dom",
|
|
|
|
// Do not exist as users, but catch-all saves them.
|
|
"x@dom", "x1@dom")
|
|
}
|
|
|
|
func TestRightSideAsterisk(t *testing.T) {
|
|
resolver := NewResolver(noUsersExist)
|
|
resolver.DropChars = "."
|
|
resolver.SuffixSep = "+"
|
|
resolver.AddDomain("dom1")
|
|
resolver.AddDomain("dom2")
|
|
resolver.AddDomain("dom3")
|
|
resolver.AddDomain("dom4")
|
|
resolver.AddDomain("dom5")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"a@dom1": {{"aaa@remote", EMAIL}},
|
|
|
|
// Note this goes to dom2 which is local too, and will be resolved
|
|
// recursively.
|
|
"*@dom1": {{"*@dom2", EMAIL}},
|
|
|
|
"b@dom2": {{"bbb@remote", EMAIL}},
|
|
"*@dom2": {{"*@remote", EMAIL}},
|
|
|
|
// A right hand asterisk on a specific address isn't very useful, but
|
|
// it is supported.
|
|
"z@dom1": {{"*@remote", EMAIL}},
|
|
|
|
// Asterisk to asterisk creates an infinite loop.
|
|
"*@dom3": {{"*@dom3", EMAIL}},
|
|
|
|
// A right-side asterisk as part of multiple addresses, some of which
|
|
// are fixed.
|
|
"*@dom4": {{"*@remote1", EMAIL}, {"*@remote2", EMAIL},
|
|
{"fixed@remote3", EMAIL}},
|
|
|
|
// A chain of a -> b -> * -> *@remote.
|
|
// This checks which one is used as the "original" user.
|
|
"a@dom5": {{"b@dom5", EMAIL}},
|
|
"*@dom5": {{"*@remote", EMAIL}},
|
|
}
|
|
|
|
cases := Cases{
|
|
{"a@dom1", []Recipient{{"aaa@remote", EMAIL}}, nil},
|
|
{"b@dom1", []Recipient{{"bbb@remote", EMAIL}}, nil},
|
|
{"xyz@dom1", []Recipient{{"xyz@remote", EMAIL}}, nil},
|
|
{"xyz@dom2", []Recipient{{"xyz@remote", EMAIL}}, nil},
|
|
{"z@dom1", []Recipient{{"z@remote", EMAIL}}, nil},
|
|
|
|
// Check that we match after dropping the characters as needed.
|
|
// This is not specific to the right side asterisk, but serve to
|
|
// confirm we're not matching against it by accident.
|
|
{"a+lala@dom1", []Recipient{{"aaa@remote", EMAIL}}, nil},
|
|
{"a..@dom1", []Recipient{{"aaa@remote", EMAIL}}, nil},
|
|
|
|
// Check we don't remove drop characters or suffixes when doing the
|
|
// rewrite: we expect to pass addresses as they come if they didn't
|
|
// match previously.
|
|
{"xyz+abcd@dom1", []Recipient{{"xyz+abcd@remote", EMAIL}}, nil},
|
|
{"x.y.z@dom1", []Recipient{{"x.y.z@remote", EMAIL}}, nil},
|
|
|
|
// This one should fail because it creates an infinite loop.
|
|
{"x@dom3", nil, ErrRecursionLimitExceeded},
|
|
|
|
// Check the multiple addresses case.
|
|
{"abc@dom4", []Recipient{
|
|
{"abc@remote1", EMAIL},
|
|
{"abc@remote2", EMAIL},
|
|
{"fixed@remote3", EMAIL},
|
|
}, nil},
|
|
|
|
// Check the chain case: a -> b -> * -> remote.
|
|
{"a@dom5", []Recipient{{"b@remote", EMAIL}}, nil},
|
|
{"b@dom5", []Recipient{{"b@remote", EMAIL}}, nil},
|
|
{"c@dom5", []Recipient{{"c@remote", EMAIL}}, nil},
|
|
}
|
|
cases.check(t, resolver)
|
|
}
|
|
|
|
func TestUserLookupErrors(t *testing.T) {
|
|
resolver := NewResolver(usersWithXErrorYDontExist)
|
|
resolver.AddDomain("dom")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"a@dom": {{"a@remote", EMAIL}},
|
|
"b@dom": {{"x@dom", EMAIL}},
|
|
"*@dom": {{"x@dom", EMAIL}},
|
|
}
|
|
|
|
cases := Cases{
|
|
{"a@dom", []Recipient{{"a@remote", EMAIL}}, nil},
|
|
{"b@dom", nil, errUserLookup},
|
|
{"c@dom", []Recipient{{"c@dom", EMAIL}}, nil},
|
|
{"x@dom", nil, errUserLookup},
|
|
|
|
// This one goes through the catch-all.
|
|
{"y@dom", nil, errUserLookup},
|
|
}
|
|
cases.check(t, resolver)
|
|
}
|
|
|
|
func TestAddrRewrite(t *testing.T) {
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("def")
|
|
resolver.AddDomain("p-q.com")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"abc@def": {{"x@y", EMAIL}},
|
|
"ñoño@def": {{"x@y", EMAIL}},
|
|
"recu@def": {{"ab+cd@p-q.com", EMAIL}},
|
|
"remo@def": {{"x-@y-z.com", EMAIL}},
|
|
|
|
// Aliases with a suffix, to make sure we handle them correctly.
|
|
// Note we don't allow aliases with drop characters, they get
|
|
// normalized at parsing time.
|
|
"recu-zzz@def": {{"z@z", EMAIL}},
|
|
}
|
|
resolver.DropChars = ".~"
|
|
resolver.SuffixSep = "-+"
|
|
|
|
cases := Cases{
|
|
{"abc@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"a.b.c@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"a~b~c@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"a.b~c@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"abc-ñaca@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"abc-ñaca@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"abc-xyz@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"abc+xyz@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
{"abc-x.y+z@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
|
|
{"ñ.o~ño-ñaca@def", []Recipient{{"x@y", EMAIL}}, nil},
|
|
|
|
// Don't mess with the domain, even if it's known.
|
|
{"a.bc-ñaca@p-q.com", []Recipient{{"abc@p-q.com", EMAIL}}, nil},
|
|
|
|
// Clean the right hand side too (if it's a local domain).
|
|
{"recu+blah@def", []Recipient{{"ab@p-q.com", EMAIL}}, nil},
|
|
|
|
// Requests for "recu" and variants, because it has an alias with a
|
|
// suffix.
|
|
{"re-cu@def", []Recipient{{"re@def", EMAIL}}, nil},
|
|
{"re.cu@def", []Recipient{{"ab@p-q.com", EMAIL}}, nil},
|
|
{"re.cu-zzz@def", []Recipient{{"z@z", EMAIL}}, nil},
|
|
|
|
// Check that because we have an alias with a suffix, we do not
|
|
// accidentally use it for their "clean" versions.
|
|
{"re@def", []Recipient{{"re@def", EMAIL}}, nil},
|
|
{"r.e.c.u@def", []Recipient{{"ab@p-q.com", EMAIL}}, nil},
|
|
{"re.cu-yyy@def", []Recipient{{"ab@p-q.com", EMAIL}}, nil},
|
|
|
|
// We should not mess with emails for domains we don't know.
|
|
{"xy@z.com", []Recipient{{"xy@z.com", EMAIL}}, nil},
|
|
{"x.y@z.com", []Recipient{{"x.y@z.com", EMAIL}}, nil},
|
|
{"x-@y-z.com", []Recipient{{"x-@y-z.com", EMAIL}}, nil},
|
|
{"x+blah@y", []Recipient{{"x+blah@y", EMAIL}}, nil},
|
|
{"remo@def", []Recipient{{"x-@y-z.com", EMAIL}}, nil},
|
|
}
|
|
cases.check(t, resolver)
|
|
}
|
|
|
|
func TestExists(t *testing.T) {
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("def")
|
|
resolver.AddDomain("p-q.com")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"abc@def": {{"x@y", EMAIL}},
|
|
"ñoño@def": {{"x@y", EMAIL}},
|
|
"recu@def": {{"ab+cd@p-q.com", EMAIL}},
|
|
|
|
// Aliases with a suffix, to make sure we handle them correctly.
|
|
// Note we don't allow aliases with drop characters, they get
|
|
// normalized at parsing time.
|
|
"ex-act@def": {{"x@y", EMAIL}},
|
|
}
|
|
resolver.DropChars = ".~"
|
|
resolver.SuffixSep = "-+"
|
|
|
|
mustExist(t, resolver,
|
|
"abc@def",
|
|
"abc+blah@def",
|
|
"a.bc+blah@def",
|
|
"a.b~c@def",
|
|
"ñoño@def",
|
|
"ño.ño@def",
|
|
"recu@def",
|
|
"re.cu@def",
|
|
"ex-act@def",
|
|
)
|
|
mustNotExist(t, resolver,
|
|
"abc@d.ef",
|
|
"nothere@def",
|
|
"ex@def",
|
|
"a.bc@unknown",
|
|
"x.yz@def",
|
|
"x.yz@d.ef",
|
|
"abc@d.ef",
|
|
"exact@def",
|
|
"exa.ct@def",
|
|
"ex@def",
|
|
)
|
|
}
|
|
|
|
func TestRemoveDropsAndSuffix(t *testing.T) {
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("def")
|
|
resolver.AddDomain("p-q.com")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"abc@def": {{"x@y", EMAIL}},
|
|
"ñoño@def": {{"x@y", EMAIL}},
|
|
"recu@def": {{"ab+cd@p-q.com", EMAIL}},
|
|
}
|
|
resolver.DropChars = ".~"
|
|
resolver.SuffixSep = "-+"
|
|
|
|
cases := []struct {
|
|
addr string
|
|
want string
|
|
}{
|
|
{"abc@def", "abc@def"},
|
|
{"abc+blah@def", "abc@def"},
|
|
{"a.b~c@def", "abc@def"},
|
|
{"a.bc+blah@def", "abc@def"},
|
|
{"x.yz@def", "xyz@def"},
|
|
{"x.yz@d.ef", "xyz@d.ef"},
|
|
}
|
|
for _, c := range cases {
|
|
addr := resolver.RemoveDropsAndSuffix(c.addr)
|
|
if addr != c.want {
|
|
t.Errorf("RemoveDropsAndSuffix(%q): want %q, got %q",
|
|
c.addr, c.want, addr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRemoveDropCharacters(t *testing.T) {
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("def")
|
|
resolver.DropChars = "._"
|
|
resolver.SuffixSep = "-+"
|
|
|
|
cases := []struct {
|
|
addr string
|
|
want string
|
|
}{
|
|
{"abc@def", "abc@def"},
|
|
{"abc+blah@def", "abc+blah@def"},
|
|
{"a.b@def", "ab@def"},
|
|
{"a.b+c@def", "ab+c@def"},
|
|
{"a.b+c.d@def", "ab+c.d@def"},
|
|
{"a@def", "a@def"},
|
|
{"a+b@def", "a+b@def"},
|
|
|
|
// Cases with UTF-8, to make sure we handle indexing correctly.
|
|
{"ñoño@def", "ñoño@def"},
|
|
{"ñoño+blah@def", "ñoño+blah@def"},
|
|
{"ño.ño@def", "ñoño@def"},
|
|
{"ño.ño+blah@def", "ñoño+blah@def"},
|
|
{"ño.ño+ñaca@def", "ñoño+ñaca@def"},
|
|
{"ño.ño+ña.ca@def", "ñoño+ña.ca@def"},
|
|
{"ño.ño+ñaña@def", "ñoño+ñaña@def"},
|
|
{"ño.ño+ña.ña@def", "ñoño+ña.ña@def"},
|
|
|
|
// Check "the other" drop char/suffix separator to make sure we
|
|
// don't skip any of them.
|
|
{"a_b@def", "ab@def"},
|
|
{"a_b-c@def", "ab-c@def"},
|
|
{"a_b-c.d@def", "ab-c.d@def"},
|
|
{"ño_ño-ña.ña@def", "ñoño-ña.ña@def"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
addr := resolver.RemoveDropCharacters(c.addr)
|
|
if addr != c.want {
|
|
t.Errorf("RemoveDropCharacters(%q): want %q, got %q",
|
|
c.addr, c.want, addr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTooMuchRecursion(t *testing.T) {
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("b")
|
|
resolver.AddDomain("d")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"a@b": {{"c@d", EMAIL}},
|
|
"c@d": {{"a@b", EMAIL}},
|
|
}
|
|
|
|
tr := trace.New("test", "TestTooMuchRecursion")
|
|
defer tr.Finish()
|
|
|
|
rs, err := resolver.Resolve(tr, "a@b")
|
|
if err != ErrRecursionLimitExceeded {
|
|
t.Errorf("expected ErrRecursionLimitExceeded, got %v", err)
|
|
}
|
|
|
|
if rs != nil {
|
|
t.Errorf("expected nil recipients, got %+v", rs)
|
|
}
|
|
}
|
|
|
|
func TestTooMuchRecursionOnCatchAll(t *testing.T) {
|
|
resolver := NewResolver(usersWithXDontExist)
|
|
resolver.AddDomain("dom")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"a@dom": {{"x@dom", EMAIL}},
|
|
"*@dom": {{"a@dom", EMAIL}},
|
|
}
|
|
|
|
cases := Cases{
|
|
// b@dom is local and exists.
|
|
{"b@dom", []Recipient{{"b@dom", EMAIL}}, nil},
|
|
|
|
// a@remote is remote.
|
|
{"a@remote", []Recipient{{"a@remote", EMAIL}}, nil},
|
|
}
|
|
cases.check(t, resolver)
|
|
|
|
for _, addr := range []string{"a@dom", "x@dom", "xx@dom"} {
|
|
tr := trace.New("TestTooMuchRecursionOnCatchAll", addr)
|
|
defer tr.Finish()
|
|
|
|
rs, err := resolver.Resolve(tr, addr)
|
|
if err != ErrRecursionLimitExceeded {
|
|
t.Errorf("%s: expected ErrRecursionLimitExceeded, got %v", addr, err)
|
|
}
|
|
if rs != nil {
|
|
t.Errorf("%s: expected nil recipients, got %+v", addr, rs)
|
|
}
|
|
}
|
|
}
|
|
|
|
func mustWriteFile(t *testing.T, content string) string {
|
|
f, err := os.CreateTemp("", "aliases_test")
|
|
if err != nil {
|
|
t.Fatalf("failed to get temp file: %v", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
_, err = f.WriteString(content)
|
|
if err != nil {
|
|
t.Fatalf("failed to write temp file: %v", err)
|
|
}
|
|
|
|
return f.Name()
|
|
}
|
|
|
|
func TestAddFile(t *testing.T) {
|
|
cases := []struct {
|
|
contents string
|
|
expected []Recipient
|
|
}{
|
|
{"", []Recipient{{"a@dom", EMAIL}}},
|
|
{"\n\n", []Recipient{{"a@dom", EMAIL}}},
|
|
{" # Comment\n", []Recipient{{"a@dom", EMAIL}}},
|
|
|
|
{"a: b\n", []Recipient{{"b@dom", EMAIL}}},
|
|
{"a:b\n", []Recipient{{"b@dom", EMAIL}}},
|
|
{"a : b \n", []Recipient{{"b@dom", EMAIL}}},
|
|
{"a:b,\n", []Recipient{{"b@dom", EMAIL}}},
|
|
|
|
{"a: |cmd\n", []Recipient{{"cmd", PIPE}}},
|
|
{"a:|cmd\n", []Recipient{{"cmd", PIPE}}},
|
|
{"a:| cmd \n", []Recipient{{"cmd", PIPE}}},
|
|
{"a :| cmd \n", []Recipient{{"cmd", PIPE}}},
|
|
{"a: | cmd arg1 arg2\n", []Recipient{{"cmd arg1 arg2", PIPE}}},
|
|
|
|
{"a: c@d, e@f, g\n",
|
|
[]Recipient{{"c@d", EMAIL}, {"e@f", EMAIL}, {"g@dom", EMAIL}}},
|
|
}
|
|
|
|
tr := trace.New("test", "TestAddFile")
|
|
defer tr.Finish()
|
|
|
|
for _, c := range cases {
|
|
fname := mustWriteFile(t, c.contents)
|
|
defer os.Remove(fname)
|
|
|
|
resolver := NewResolver(allUsersExist)
|
|
_, err := resolver.AddAliasesFile("dom", fname)
|
|
if err != nil {
|
|
t.Fatalf("case %q, error adding file: %v", c.contents, err)
|
|
}
|
|
|
|
got, err := resolver.Resolve(tr, "a@dom")
|
|
if err != nil {
|
|
t.Errorf("case %q, got error: %v", c.contents, err)
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(got, c.expected) {
|
|
t.Errorf("case %q, got %v, expected %v", c.contents, got, c.expected)
|
|
}
|
|
}
|
|
|
|
// Error cases.
|
|
errcases := []struct {
|
|
contents string
|
|
expected string
|
|
}{
|
|
{":\n", "line 1: missing address or alias"},
|
|
{"a: \n", "line 1: missing address or alias"},
|
|
{"a:|\n", "right-side: the pipe alias is missing a command"},
|
|
{"a:| \n", "right-side: the pipe alias is missing a command"},
|
|
{"a@dom: b@c \n", "left-side: cannot contain @"},
|
|
{"a", "line 1: missing ':' in line"},
|
|
{"a: x y z\n", "disallowed rune encountered"},
|
|
}
|
|
|
|
for _, c := range errcases {
|
|
fname := mustWriteFile(t, c.contents)
|
|
defer os.Remove(fname)
|
|
|
|
resolver := NewResolver(allUsersExist)
|
|
_, err := resolver.AddAliasesFile("dom", fname)
|
|
if err == nil {
|
|
t.Errorf("case %q, expected error, got nil (aliases: %v)",
|
|
c.contents, resolver.aliases)
|
|
} else if !strings.Contains(err.Error(), c.expected) {
|
|
t.Errorf("case %q, got error %q, expected it to contain %q",
|
|
c.contents, err.Error(), c.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
const richFileContents = `
|
|
# This is a "complex" alias file, with a few tricky situations.
|
|
# It is used in TestRichFile.
|
|
|
|
# First some valid cases.
|
|
a: b
|
|
c: d@e, f,
|
|
x: | command
|
|
|
|
# Overrides.
|
|
o1: a
|
|
o1: b
|
|
|
|
# Check that we normalize the right hand side.
|
|
aA: bB@dom-B
|
|
|
|
# Test that exact aliases take precedence.
|
|
pq: pa
|
|
p.q: pb
|
|
p.q+r: pc
|
|
pq+r: pd
|
|
ppp1: p.q+r
|
|
ppp2: p.q
|
|
ppp3: ppp2
|
|
|
|
# Finally one to make the file NOT end in \n:
|
|
y: z`
|
|
|
|
func TestRichFile(t *testing.T) {
|
|
fname := mustWriteFile(t, richFileContents)
|
|
defer os.Remove(fname)
|
|
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.DropChars = "."
|
|
resolver.SuffixSep = "+"
|
|
n, err := resolver.AddAliasesFile("dom", fname)
|
|
if err != nil {
|
|
t.Fatalf("failed to add file: %v", err)
|
|
}
|
|
|
|
if n != 11 {
|
|
t.Fatalf("expected 11 aliases, got %d", n)
|
|
}
|
|
|
|
cases := Cases{
|
|
{"a@dom", []Recipient{{"b@dom", EMAIL}}, nil},
|
|
{"c@dom", []Recipient{{"d@e", EMAIL}, {"f@dom", EMAIL}}, nil},
|
|
{"x@dom", []Recipient{{"command", PIPE}}, nil},
|
|
|
|
{"o1@dom", []Recipient{{"b@dom", EMAIL}}, nil},
|
|
|
|
{"aA@dom", []Recipient{{"bb@dom-b", EMAIL}}, nil},
|
|
{"aa@dom", []Recipient{{"bb@dom-b", EMAIL}}, nil},
|
|
|
|
{"pq@dom", []Recipient{{"pb@dom", EMAIL}}, nil},
|
|
{"p.q@dom", []Recipient{{"pb@dom", EMAIL}}, nil},
|
|
{"p.q+r@dom", []Recipient{{"pd@dom", EMAIL}}, nil},
|
|
{"pq+r@dom", []Recipient{{"pd@dom", EMAIL}}, nil},
|
|
{"pq+z@dom", []Recipient{{"pb@dom", EMAIL}}, nil},
|
|
{"p..q@dom", []Recipient{{"pb@dom", EMAIL}}, nil},
|
|
{"p..q+r@dom", []Recipient{{"pd@dom", EMAIL}}, nil},
|
|
{"ppp1@dom", []Recipient{{"pd@dom", EMAIL}}, nil},
|
|
{"ppp2@dom", []Recipient{{"pb@dom", EMAIL}}, nil},
|
|
{"ppp3@dom", []Recipient{{"pb@dom", EMAIL}}, nil},
|
|
|
|
{"y@dom", []Recipient{{"z@dom", EMAIL}}, nil},
|
|
}
|
|
cases.check(t, resolver)
|
|
}
|
|
|
|
func TestManyFiles(t *testing.T) {
|
|
files := map[string]string{
|
|
"d1": mustWriteFile(t, "a: b\nc:d@e"),
|
|
"domain2": mustWriteFile(t, "a: b\nc:d@e"),
|
|
"dom3": mustWriteFile(t, "x: y, z"),
|
|
"dom4": mustWriteFile(t, "a: |cmd"),
|
|
|
|
// Cross-domain.
|
|
"xd1": mustWriteFile(t, "a: b@xd2"),
|
|
"xd2": mustWriteFile(t, "b: |cmd"),
|
|
}
|
|
for _, fname := range files {
|
|
defer os.Remove(fname)
|
|
}
|
|
|
|
resolver := NewResolver(allUsersExist)
|
|
for domain, fname := range files {
|
|
_, err := resolver.AddAliasesFile(domain, fname)
|
|
if err != nil {
|
|
t.Fatalf("failed to add file: %v", err)
|
|
}
|
|
}
|
|
|
|
check := func() {
|
|
cases := Cases{
|
|
{"a@d1", []Recipient{{"b@d1", EMAIL}}, nil},
|
|
{"c@d1", []Recipient{{"d@e", EMAIL}}, nil},
|
|
{"x@d1", []Recipient{{"x@d1", EMAIL}}, nil},
|
|
{"a@domain2", []Recipient{{"b@domain2", EMAIL}}, nil},
|
|
{"c@domain2", []Recipient{{"d@e", EMAIL}}, nil},
|
|
{"x@dom3", []Recipient{{"y@dom3", EMAIL}, {"z@dom3", EMAIL}}, nil},
|
|
{"a@dom4", []Recipient{{"cmd", PIPE}}, nil},
|
|
{"a@xd1", []Recipient{{"cmd", PIPE}}, nil},
|
|
}
|
|
cases.check(t, resolver)
|
|
}
|
|
|
|
check()
|
|
|
|
// Reload, and check again just in case.
|
|
if err := resolver.Reload(); err != nil {
|
|
t.Fatalf("failed to reload: %v", err)
|
|
}
|
|
check()
|
|
|
|
// Make one of the files invalid, then reload. Reload should return an
|
|
// error, and leave the resolver unchanged.
|
|
if err := os.WriteFile(files["d1"], []byte("invalid\n"), 0644); err != nil {
|
|
t.Fatalf("failed to write file: %v", err)
|
|
}
|
|
err := resolver.Reload()
|
|
if err == nil {
|
|
t.Fatalf("expected error, got nil")
|
|
} else if !strings.Contains(err.Error(), "line 1: missing ':' in line") {
|
|
t.Fatalf("expected error to contain 'missing :', got %v", err)
|
|
}
|
|
check()
|
|
}
|
|
|
|
func TestHook(t *testing.T) {
|
|
tr := trace.New("TestHook", "test")
|
|
defer tr.Finish()
|
|
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("localA")
|
|
resolver.aliases = map[string][]Recipient{
|
|
"a@localA": {{"c@d", EMAIL}},
|
|
}
|
|
|
|
// First check that the test is set up reasonably.
|
|
mustExist(t, resolver, "a@localA")
|
|
Cases{
|
|
{"a@localA", []Recipient{{"c@d", EMAIL}}, nil},
|
|
}.check(t, resolver)
|
|
|
|
// Test that the empty hook is run correctly.
|
|
resolver.ResolveHook = "testdata/empty-hook.sh"
|
|
mustExist(t, resolver, "a@localA")
|
|
Cases{
|
|
{"a@localA", []Recipient{{"c@d", EMAIL}}, nil},
|
|
}.check(t, resolver)
|
|
|
|
// Test that a normal hook is run correctly.
|
|
resolver.ResolveHook = "testdata/normal-hook.sh"
|
|
mustExist(t, resolver, "a@localA")
|
|
Cases{
|
|
{"a@localA", []Recipient{
|
|
{"c@d", EMAIL}, // From the internal aliases.
|
|
{"p@q", EMAIL}, // From the hook.
|
|
{"x@y", EMAIL}, // From the hook.
|
|
}, nil},
|
|
}.check(t, resolver)
|
|
|
|
// Test that a non-existent hook is ignored.
|
|
resolver.ResolveHook = "testdata/doesnotexist"
|
|
mustExist(t, resolver, "a@localA")
|
|
Cases{
|
|
{"a@localA", []Recipient{{"c@d", EMAIL}}, nil},
|
|
}.check(t, resolver)
|
|
|
|
// Test a hook that returns an invalid alias.
|
|
resolver.ResolveHook = "testdata/invalid-hook.sh"
|
|
mustNotExist(t, resolver, "a@localA")
|
|
|
|
rcpts, err := resolver.Resolve(tr, "a@localA")
|
|
if len(rcpts) != 0 {
|
|
t.Errorf("expected no recipients, got %v", rcpts)
|
|
}
|
|
if !strings.Contains(err.Error(), "the pipe alias is missing a command") {
|
|
t.Errorf("expected 'the pipe alias is missing a command', got: %v", err)
|
|
}
|
|
|
|
// Now use a resolver that exits with an error.
|
|
resolver.ResolveHook = "testdata/erroring-hook.sh"
|
|
|
|
// Check that the hook is run and the error is propagated.
|
|
mustNotExist(t, resolver, "a@localA")
|
|
rcpts, err = resolver.Resolve(tr, "a@localA")
|
|
if len(rcpts) != 0 {
|
|
t.Errorf("expected no recipients, got %v", rcpts)
|
|
}
|
|
execErr := &exec.ExitError{}
|
|
if !errors.As(err, &execErr) {
|
|
t.Errorf("expected *exec.ExitError, got %T - %v", err, err)
|
|
}
|
|
}
|
|
|
|
// Fuzz testing for the parser.
|
|
func FuzzReader(f *testing.F) {
|
|
resolver := NewResolver(allUsersExist)
|
|
resolver.AddDomain("domain")
|
|
resolver.DropChars = "."
|
|
resolver.SuffixSep = "-+"
|
|
f.Add([]byte(richFileContents))
|
|
f.Fuzz(func(t *testing.T, data []byte) {
|
|
resolver.parseReader("domain", bytes.NewReader(data))
|
|
})
|
|
}
|