144 lines
4.2 KiB
Go
144 lines
4.2 KiB
Go
package dovecot
|
|
|
|
// The dovecot package is mainly tested via integration/external tests using
|
|
// the dovecot-auth-cli tool. See cmd/dovecot-auth-cli for more details.
|
|
// The tests here are more narrow and only test specific functionality that is
|
|
// easier to cover from Go.
|
|
|
|
import (
|
|
"net"
|
|
"net/url"
|
|
"testing"
|
|
|
|
"blitiri.com.ar/go/chasquid/internal/testlib"
|
|
)
|
|
|
|
func TestUsernameNotSafe(t *testing.T) {
|
|
a := NewAuth("/tmp/nothing", "/tmp/nothing")
|
|
|
|
cases := []string{
|
|
"a b", " ab", "ab ", "a\tb", "a\t", " ", "\t", "\t "}
|
|
for _, c := range cases {
|
|
ok, err := a.Authenticate(c, "passwd")
|
|
if ok || err != errUsernameNotSafe {
|
|
t.Errorf("Authenticate(%q, _): got %v, %v", c, ok, err)
|
|
}
|
|
|
|
ok, err = a.Exists(c)
|
|
if ok || err != errUsernameNotSafe {
|
|
t.Errorf("Exists(%q): got %v, %v", c, ok, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAutodetect(t *testing.T) {
|
|
// Check on a pair that does not exist.
|
|
a := NewAuth("uDoesNotExist", "cDoesNotExist")
|
|
err := a.Check()
|
|
if err != errFailedToConnect {
|
|
t.Errorf("Expected failure to connect, got %v", err)
|
|
}
|
|
|
|
// We override the default paths, so we can point the "defaults" to our
|
|
// test environment as needed.
|
|
defaultUserdbPaths = []*url.URL{{Scheme: "unix", Path: "/dev/null"}}
|
|
defaultClientPaths = []*url.URL{{Scheme: "unix", Path: "/dev/null"}}
|
|
|
|
// Autodetect failure: no valid sockets on the list.
|
|
a = NewAuth("", "")
|
|
err = a.Check()
|
|
if err != errNoUserdbSocket {
|
|
t.Errorf("Expected failure to find userdb socket, got %v", err)
|
|
}
|
|
ok, err := a.Exists("user")
|
|
if ok != false || err != errNoUserdbSocket {
|
|
t.Errorf("Expected {false, no userdb socket}, got {%v, %v}", ok, err)
|
|
}
|
|
ok, err = a.Authenticate("user", "password")
|
|
if ok != false || err != errNoUserdbSocket {
|
|
t.Errorf("Expected {false, no userdb socket}, got {%v, %v}", ok, err)
|
|
}
|
|
|
|
// Create a temporary directory, and two sockets on it.
|
|
dir := testlib.MustTempDir(t)
|
|
defer testlib.RemoveIfOk(t, dir)
|
|
|
|
userdb := &url.URL{Scheme: "unix", Path: dir + "/userdb"}
|
|
client := &url.URL{Scheme: "unix", Path: dir + "/client"}
|
|
|
|
uL := mustListen(t, userdb.Path)
|
|
cL := mustListen(t, client.Path)
|
|
|
|
// Autodetect finds the user, but fails to find the client.
|
|
defaultUserdbPaths = []*url.URL{{Scheme: "unix", Path: "/dev/null"}, userdb}
|
|
defaultClientPaths = []*url.URL{{Scheme: "unix", Path: "/dev/null"}}
|
|
a = NewAuth("", "")
|
|
err = a.Check()
|
|
if err != errNoClientSocket {
|
|
t.Errorf("Expected failure to find client socket, got %v", err)
|
|
}
|
|
|
|
// Autodetect should pick the suggestions passed as parameters (if
|
|
// possible).
|
|
defaultUserdbPaths = []*url.URL{{Scheme: "unix", Path: "/dev/null"}}
|
|
defaultClientPaths = []*url.URL{{Scheme: "unix", Path: "/dev/null"}, client}
|
|
a = NewAuth(userdb.String(), "")
|
|
err = a.Check()
|
|
if err != nil {
|
|
t.Errorf("Expected successful check, got %v", err)
|
|
}
|
|
if a.addr.userdb != userdb.String() || a.addr.client != client.String() {
|
|
t.Errorf("Expected autodetect to pick {%q, %q}, but got {%q, %q}",
|
|
userdb, client, a.addr.userdb, a.addr.client)
|
|
}
|
|
|
|
// Successful autodetection against open sockets.
|
|
defaultUserdbPaths = append(defaultUserdbPaths, userdb)
|
|
defaultClientPaths = append(defaultClientPaths, client)
|
|
a = NewAuth("", "")
|
|
err = a.Check()
|
|
if err != nil {
|
|
t.Errorf("Expected successful check, got %v", err)
|
|
}
|
|
|
|
// Close the two sockets, and re-do the check: now we have pinned the
|
|
// paths, and check should fail to connect.
|
|
// We need to tell Go to keep the socket files around explicitly, as the
|
|
// default is to delete them since they were created by the net library.
|
|
uL.SetUnlinkOnClose(false)
|
|
uL.Close()
|
|
err = a.Check()
|
|
if err != errFailedToConnect {
|
|
t.Errorf("Expected failed to connect, got %v", err)
|
|
}
|
|
|
|
cL.SetUnlinkOnClose(false)
|
|
cL.Close()
|
|
err = a.Check()
|
|
if err != errFailedToConnect {
|
|
t.Errorf("Expected failed to connect, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestReload(t *testing.T) {
|
|
// Make sure Reload does not fail.
|
|
a := Auth{}
|
|
if err := a.Reload(); err != nil {
|
|
t.Errorf("Reload failed")
|
|
}
|
|
}
|
|
|
|
func mustListen(t *testing.T, path string) *net.UnixListener {
|
|
addr, err := net.ResolveUnixAddr("unix", path)
|
|
if err != nil {
|
|
t.Fatalf("failed to resolve unix addr %q: %v", path, err)
|
|
}
|
|
|
|
l, err := net.ListenUnix("unix", addr)
|
|
if err != nil {
|
|
t.Fatalf("failed to listen on %q: %v", path, err)
|
|
}
|
|
|
|
return l
|
|
}
|