Use Serve in tests to avoid port contention

3 files changed, 115 insertions, 75 deletions

diff --git a/server_modify_test.go b/server_modify_test.go
index 7050a32..6705343 100644
--- a/server_modify_test.go
+++ b/server_modify_test.go
@@ -13,20 +13,21 @@ func TestAdd(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", modifyTestHandler{})
 		s.AddFunc("", modifyTestHandler{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 	go func() {
-		cmd := exec.Command("ldapadd", "-v", "-H", ldapURL, "-x", "-f", "tests/add.ldif")
+		cmd := exec.Command("ldapadd", "-v", "-H", "ldap://"+addr, "-x", "-f", "tests/add.ldif")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "modify complete") {
 			t.Errorf("ldapadd failed: %v", string(out))
 		}
-		cmd = exec.Command("ldapadd", "-v", "-H", ldapURL, "-x", "-f", "tests/add2.ldif")
+		cmd = exec.Command("ldapadd", "-v", "-H", "ldap://"+addr, "-x", "-f", "tests/add2.ldif")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "ldap_add: Insufficient access") {
 			t.Errorf("ldapadd should have failed: %v", string(out))
@@ -48,20 +49,21 @@ func TestDelete(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", modifyTestHandler{})
 		s.DeleteFunc("", modifyTestHandler{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 	go func() {
-		cmd := exec.Command("ldapdelete", "-v", "-H", ldapURL, "-x", "cn=Delete Me,dc=example,dc=com")
+		cmd := exec.Command("ldapdelete", "-v", "-H", "ldap://"+addr, "-x", "cn=Delete Me,dc=example,dc=com")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "Delete Result: Success (0)") || !strings.Contains(string(out), "Additional info: Success") {
 			t.Errorf("ldapdelete failed: %v", string(out))
 		}
-		cmd = exec.Command("ldapdelete", "-v", "-H", ldapURL, "-x", "cn=Bob,dc=example,dc=com")
+		cmd = exec.Command("ldapdelete", "-v", "-H", "ldap://"+addr, "-x", "cn=Bob,dc=example,dc=com")
 		out, _ = cmd.CombinedOutput()
 		if strings.Contains(string(out), "Success") || !strings.Contains(string(out), "ldap_delete: Insufficient access") {
 			t.Errorf("ldapdelete should have failed: %v", string(out))
@@ -79,20 +81,21 @@ func TestModify(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", modifyTestHandler{})
 		s.ModifyFunc("", modifyTestHandler{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 	go func() {
-		cmd := exec.Command("ldapmodify", "-v", "-H", ldapURL, "-x", "-f", "tests/modify.ldif")
+		cmd := exec.Command("ldapmodify", "-v", "-H", "ldap://"+addr, "-x", "-f", "tests/modify.ldif")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "modify complete") {
 			t.Errorf("ldapmodify failed: %v", string(out))
 		}
-		cmd = exec.Command("ldapmodify", "-v", "-H", ldapURL, "-x", "-f", "tests/modify2.ldif")
+		cmd = exec.Command("ldapmodify", "-v", "-H", "ldap://"+addr, "-x", "-f", "tests/modify2.ldif")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "ldap_modify: Insufficient access") || strings.Contains(string(out), "modify complete") {
 			t.Errorf("ldapmodify should have failed: %v", string(out))
diff --git a/server_search_test.go b/server_search_test.go
index f0345f7..6325984 100644
--- a/server_search_test.go
+++ b/server_search_test.go
@@ -12,18 +12,19 @@ func TestSearchSimpleOK(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.SearchFunc("", searchSimple{})
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	serverBaseDN := "o=testers,c=test"
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "dn: cn=ned,o=testers,c=test") {
@@ -52,17 +53,18 @@ func TestSearchSizelimit(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.EnforceLDAP = true
 		s.SearchFunc("", searchSimple{})
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test") // no limit for this test
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -72,7 +74,7 @@ func TestSearchSizelimit(t *testing.T) {
 			t.Errorf("ldapsearch sizelimit unlimited failed - not enough entries: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", "-z", "9") // effectively no limit for this test
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -82,7 +84,7 @@ func TestSearchSizelimit(t *testing.T) {
 			t.Errorf("ldapsearch sizelimit 9 failed - not enough entries: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", "-z", "2")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -92,7 +94,7 @@ func TestSearchSizelimit(t *testing.T) {
 			t.Errorf("ldapsearch sizelimit 2 failed - too many entries: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", "-z", "1")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -102,7 +104,7 @@ func TestSearchSizelimit(t *testing.T) {
 			t.Errorf("ldapsearch sizelimit 1 failed - too many entries: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", "-z", "0")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -112,7 +114,7 @@ func TestSearchSizelimit(t *testing.T) {
 			t.Errorf("ldapsearch sizelimit 0 failed - wrong number of entries: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", "-z", "1", "(uid=trent)")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -122,7 +124,7 @@ func TestSearchSizelimit(t *testing.T) {
 			t.Errorf("ldapsearch sizelimit 1 with filter failed - wrong number of entries: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", "-z", "0", "(uid=trent)")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -146,18 +148,19 @@ func TestBindSearchMulti(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", bindSimple{})
 		s.BindFunc("c=testz", bindSimple2{})
 		s.SearchFunc("", searchSimple{})
 		s.SearchFunc("c=testz", searchSimple2{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x", "-b", "o=testers,c=test",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x", "-b", "o=testers,c=test",
 			"-D", "cn=testy,o=testers,c=test", "-w", "iLike2test", "cn=ned")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -166,7 +169,7 @@ func TestBindSearchMulti(t *testing.T) {
 		if !strings.Contains(string(out), "dn: cn=ned,o=testers,c=test") {
 			t.Errorf("search default routing failed: %v", string(out))
 		}
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x", "-b", "o=testers,c=testz",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x", "-b", "o=testers,c=testz",
 			"-D", "cn=testy,o=testers,c=testz", "-w", "ZLike2test", "cn=hamburger")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -190,16 +193,17 @@ func TestSearchPanic(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.SearchFunc("", searchPanic{})
 		s.BindFunc("", bindAnonOK{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x", "-b", "o=testers,c=test")
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x", "-b", "o=testers,c=test")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 1 Operations error") {
 			t.Errorf("ldapsearch should have returned operations error due to panic: %v", string(out))
@@ -254,12 +258,13 @@ func TestSearchFiltering(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.EnforceLDAP = true
 		s.SearchFunc("", searchSimple{})
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
@@ -267,7 +272,7 @@ func TestSearchFiltering(t *testing.T) {
 		t.Log(i.name)
 
 		go func() {
-			cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+			cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 				"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", i.filterStr)
 			out, _ := cmd.CombinedOutput()
 			if !strings.Contains(string(out), "numResponses: "+i.numResponses) {
@@ -289,18 +294,19 @@ func TestSearchAttributes(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.EnforceLDAP = true
 		s.SearchFunc("", searchSimple{})
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
 		filterString := ""
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", filterString, "cn")
 		out, _ := cmd.CombinedOutput()
 
@@ -331,43 +337,44 @@ func TestSearchScope(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.EnforceLDAP = true
 		s.SearchFunc("", searchSimple{})
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", "c=test", "-D", "cn=testy,o=testers,c=test", "-w", "iLike2test", "-s", "sub", "cn=trent")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "dn: cn=trent,o=testers,c=test") {
 			t.Errorf("ldapsearch 'sub' scope failed - didn't find expected DN: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", "o=testers,c=test", "-D", "cn=testy,o=testers,c=test", "-w", "iLike2test", "-s", "one", "cn=trent")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "dn: cn=trent,o=testers,c=test") {
 			t.Errorf("ldapsearch 'one' scope failed - didn't find expected DN: %v", string(out))
 		}
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", "c=test", "-D", "cn=testy,o=testers,c=test", "-w", "iLike2test", "-s", "one", "cn=trent")
 		out, _ = cmd.CombinedOutput()
 		if strings.Contains(string(out), "dn: cn=trent,o=testers,c=test") {
 			t.Errorf("ldapsearch 'one' scope failed - found unexpected DN: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", "cn=trent,o=testers,c=test", "-D", "cn=testy,o=testers,c=test", "-w", "iLike2test", "-s", "base", "cn=trent")
 		out, _ = cmd.CombinedOutput()
 		if !strings.Contains(string(out), "dn: cn=trent,o=testers,c=test") {
 			t.Errorf("ldapsearch 'base' scope failed - didn't find expected DN: %v", string(out))
 		}
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", "o=testers,c=test", "-D", "cn=testy,o=testers,c=test", "-w", "iLike2test", "-s", "base", "cn=trent")
 		out, _ = cmd.CombinedOutput()
 		if strings.Contains(string(out), "dn: cn=trent,o=testers,c=test") {
@@ -379,7 +386,7 @@ func TestSearchScope(t *testing.T) {
 
 	select {
 	case <-done:
-	case <-time.After(timeout):
+	case <-time.After(2*timeout):
 		t.Errorf("ldapsearch command timed out")
 	}
 }
@@ -388,18 +395,19 @@ func TestSearchControls(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.SearchFunc("", searchControls{})
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	serverBaseDN := "o=testers,c=test"
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test", "-e", "1.2.3.4.5")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "dn: cn=hamburger,o=testers,c=testz") {
@@ -412,7 +420,7 @@ func TestSearchControls(t *testing.T) {
 			t.Errorf("ldapsearch with control failed: %v", string(out))
 		}
 
-		cmd = exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd = exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test")
 		out, _ = cmd.CombinedOutput()
 		if strings.Contains(string(out), "dn: cn=hamburger,o=testers,c=testz") {
diff --git a/server_test.go b/server_test.go
index 87beb62..d7527f4 100644
--- a/server_test.go
+++ b/server_test.go
@@ -2,6 +2,7 @@ package ldapserver
 
 import (
 	"bytes"
+	"crypto/tls"
 	"log"
 	"net"
 	"os/exec"
@@ -10,8 +11,6 @@ import (
 	"time"
 )
 
-var listenString = "localhost:3389"
-var ldapURL = "ldap://" + listenString
 var timeout = 400 * time.Millisecond
 var serverBaseDN = "o=testers,c=test"
 
@@ -20,15 +19,16 @@ func TestBindAnonOK(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", bindAnonOK{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x", "-b", "o=testers,c=test")
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x", "-b", "o=testers,c=test")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
 			t.Errorf("ldapsearch failed: %v", string(out))
@@ -48,15 +48,16 @@ func TestBindAnonFail(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	time.Sleep(timeout)
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x", "-b", "o=testers,c=test")
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x", "-b", "o=testers,c=test")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "ldap_bind: Invalid credentials (49)") {
 			t.Errorf("ldapsearch failed: %v", string(out))
@@ -76,18 +77,19 @@ func TestBindSimpleOK(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.SearchFunc("", searchSimple{})
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	serverBaseDN := "o=testers,c=test"
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "iLike2test")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
@@ -108,17 +110,18 @@ func TestBindSimpleFailBadPw(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	serverBaseDN := "o=testers,c=test"
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testy,"+serverBaseDN, "-w", "BADPassword")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "ldap_bind: Invalid credentials (49)") {
@@ -139,17 +142,18 @@ func TestBindSimpleFailBadDn(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", bindSimple{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	serverBaseDN := "o=testers,c=test"
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x",
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x",
 			"-b", serverBaseDN, "-D", "cn=testoy,"+serverBaseDN, "-w", "iLike2test")
 		out, _ := cmd.CombinedOutput()
 		if string(out) != "ldap_bind: Invalid credentials (49)\n" {
@@ -168,15 +172,28 @@ func TestBindSimpleFailBadDn(t *testing.T) {
 /////////////////////////
 func TestBindSSL(t *testing.T) {
 	t.Skip("unclear how to configure ldapsearch command to trust or skip verification of a custom SSL cert")
-	ldapURLSSL := "ldaps://" + listenString
 	longerTimeout := 300 * time.Millisecond
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+
+	cert, err := tls.LoadX509KeyPair("tests/cert_DONOTUSE.pem", "tests/key_DONOTUSE.pem")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tlsConfig := tls.Config{Certificates: []tls.Certificate{cert}}
+	tlsConfig.ServerName = "localhost"
+	ln, err := tls.Listen("tcp", "localhost:0", &tlsConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ldapURLSSL := "ldaps://" + ln.Addr().String()
+
 	go func() {
 		s.BindFunc("", bindAnonOK{})
-		if err := s.ListenAndServeTLS(listenString, "tests/cert_DONOTUSE.pem", "tests/key_DONOTUSE.pem"); err != nil {
-			t.Errorf("s.ListenAndServeTLS failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
@@ -206,15 +223,16 @@ func TestBindPanic(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 	go func() {
 		s.BindFunc("", bindPanic{})
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x", "-b", "o=testers,c=test")
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x", "-b", "o=testers,c=test")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "ldap_bind: Operations error") {
 			t.Errorf("ldapsearch should have returned operations error due to panic: %v", string(out))
@@ -246,18 +264,19 @@ func TestSearchStats(t *testing.T) {
 	done := make(chan bool)
 	s := NewServer()
 	defer s.Close()
+	ln, addr := mustListen()
 
 	go func() {
 		s.SearchFunc("", searchSimple{})
 		s.BindFunc("", bindAnonOK{})
 		s.SetStats(true)
-		if err := s.ListenAndServe(listenString); err != nil {
-			t.Errorf("s.ListenAndServe failed: %s", err.Error())
+		if err := s.Serve(ln); err != nil {
+			t.Errorf("s.Serve failed: %s", err.Error())
 		}
 	}()
 
 	go func() {
-		cmd := exec.Command("ldapsearch", "-H", ldapURL, "-x", "-b", "o=testers,c=test")
+		cmd := exec.Command("ldapsearch", "-H", "ldap://"+addr, "-x", "-b", "o=testers,c=test")
 		out, _ := cmd.CombinedOutput()
 		if !strings.Contains(string(out), "result: 0 Success") {
 			t.Errorf("ldapsearch failed: %v", string(out))
@@ -396,3 +415,13 @@ func (s searchControls) Search(boundDN string, searchReq SearchRequest, conn net
 	}
 	return ServerSearchResult{entries, []string{}, []Control{}, LDAPResultSuccess}, nil
 }
+
+// mustListen returns a net.Listener listening on a random port.
+func mustListen() (ln net.Listener, actualAddr string) {
+	ln, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		panic(err)
+	}
+
+	return ln, ln.Addr().String()
+}