aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--server_modify_test.go27
-rw-r--r--server_search_test.go82
-rw-r--r--server_test.go81
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()
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-01-26 21:54:55 +0000