github.com/go-ldap/ldap@v3.0.3+incompatible/ldap_test.go (about) 1 package ldap 2 3 import ( 4 "crypto/tls" 5 "fmt" 6 "testing" 7 ) 8 9 var ldapServer = "ldap.itd.umich.edu" 10 var ldapPort = uint16(389) 11 var ldapTLSPort = uint16(636) 12 var baseDN = "dc=umich,dc=edu" 13 var filter = []string{ 14 "(cn=cis-fac)", 15 "(&(owner=*)(cn=cis-fac))", 16 "(&(objectclass=rfc822mailgroup)(cn=*Computer*))", 17 "(&(objectclass=rfc822mailgroup)(cn=*Mathematics*))"} 18 var attributes = []string{ 19 "cn", 20 "description"} 21 22 func TestDial(t *testing.T) { 23 fmt.Printf("TestDial: starting...\n") 24 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 25 if err != nil { 26 t.Errorf(err.Error()) 27 return 28 } 29 defer l.Close() 30 fmt.Printf("TestDial: finished...\n") 31 } 32 33 func TestDialTLS(t *testing.T) { 34 fmt.Printf("TestDialTLS: starting...\n") 35 l, err := DialTLS("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapTLSPort), &tls.Config{InsecureSkipVerify: true}) 36 if err != nil { 37 t.Errorf(err.Error()) 38 return 39 } 40 defer l.Close() 41 fmt.Printf("TestDialTLS: finished...\n") 42 } 43 44 func TestStartTLS(t *testing.T) { 45 fmt.Printf("TestStartTLS: starting...\n") 46 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 47 if err != nil { 48 t.Errorf(err.Error()) 49 return 50 } 51 err = l.StartTLS(&tls.Config{InsecureSkipVerify: true}) 52 if err != nil { 53 t.Errorf(err.Error()) 54 return 55 } 56 fmt.Printf("TestStartTLS: finished...\n") 57 } 58 59 func TestTLSConnectionState(t *testing.T) { 60 fmt.Printf("TestTLSConnectionState: starting...\n") 61 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 62 if err != nil { 63 t.Errorf(err.Error()) 64 return 65 } 66 err = l.StartTLS(&tls.Config{InsecureSkipVerify: true}) 67 if err != nil { 68 t.Errorf(err.Error()) 69 return 70 } 71 72 cs, ok := l.TLSConnectionState() 73 if !ok { 74 t.Errorf("TLSConnectionState returned ok == false; want true") 75 } 76 if cs.Version == 0 || !cs.HandshakeComplete { 77 t.Errorf("ConnectionState = %#v; expected Version != 0 and HandshakeComplete = true", cs) 78 } 79 80 fmt.Printf("TestTLSConnectionState: finished...\n") 81 } 82 83 func TestSearch(t *testing.T) { 84 fmt.Printf("TestSearch: starting...\n") 85 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 86 if err != nil { 87 t.Errorf(err.Error()) 88 return 89 } 90 defer l.Close() 91 92 searchRequest := NewSearchRequest( 93 baseDN, 94 ScopeWholeSubtree, DerefAlways, 0, 0, false, 95 filter[0], 96 attributes, 97 nil) 98 99 sr, err := l.Search(searchRequest) 100 if err != nil { 101 t.Errorf(err.Error()) 102 return 103 } 104 105 fmt.Printf("TestSearch: %s -> num of entries = %d\n", searchRequest.Filter, len(sr.Entries)) 106 } 107 108 func TestSearchStartTLS(t *testing.T) { 109 fmt.Printf("TestSearchStartTLS: starting...\n") 110 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 111 if err != nil { 112 t.Errorf(err.Error()) 113 return 114 } 115 defer l.Close() 116 117 searchRequest := NewSearchRequest( 118 baseDN, 119 ScopeWholeSubtree, DerefAlways, 0, 0, false, 120 filter[0], 121 attributes, 122 nil) 123 124 sr, err := l.Search(searchRequest) 125 if err != nil { 126 t.Errorf(err.Error()) 127 return 128 } 129 130 fmt.Printf("TestSearchStartTLS: %s -> num of entries = %d\n", searchRequest.Filter, len(sr.Entries)) 131 132 fmt.Printf("TestSearchStartTLS: upgrading with startTLS\n") 133 err = l.StartTLS(&tls.Config{InsecureSkipVerify: true}) 134 if err != nil { 135 t.Errorf(err.Error()) 136 return 137 } 138 139 sr, err = l.Search(searchRequest) 140 if err != nil { 141 t.Errorf(err.Error()) 142 return 143 } 144 145 fmt.Printf("TestSearchStartTLS: %s -> num of entries = %d\n", searchRequest.Filter, len(sr.Entries)) 146 } 147 148 func TestSearchWithPaging(t *testing.T) { 149 fmt.Printf("TestSearchWithPaging: starting...\n") 150 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 151 if err != nil { 152 t.Errorf(err.Error()) 153 return 154 } 155 defer l.Close() 156 157 err = l.UnauthenticatedBind("") 158 if err != nil { 159 t.Errorf(err.Error()) 160 return 161 } 162 163 searchRequest := NewSearchRequest( 164 baseDN, 165 ScopeWholeSubtree, DerefAlways, 0, 0, false, 166 filter[2], 167 attributes, 168 nil) 169 sr, err := l.SearchWithPaging(searchRequest, 5) 170 if err != nil { 171 t.Errorf(err.Error()) 172 return 173 } 174 175 fmt.Printf("TestSearchWithPaging: %s -> num of entries = %d\n", searchRequest.Filter, len(sr.Entries)) 176 177 searchRequest = NewSearchRequest( 178 baseDN, 179 ScopeWholeSubtree, DerefAlways, 0, 0, false, 180 filter[2], 181 attributes, 182 []Control{NewControlPaging(5)}) 183 sr, err = l.SearchWithPaging(searchRequest, 5) 184 if err != nil { 185 t.Errorf(err.Error()) 186 return 187 } 188 189 fmt.Printf("TestSearchWithPaging: %s -> num of entries = %d\n", searchRequest.Filter, len(sr.Entries)) 190 191 searchRequest = NewSearchRequest( 192 baseDN, 193 ScopeWholeSubtree, DerefAlways, 0, 0, false, 194 filter[2], 195 attributes, 196 []Control{NewControlPaging(500)}) 197 sr, err = l.SearchWithPaging(searchRequest, 5) 198 if err == nil { 199 t.Errorf("expected an error when paging size in control in search request doesn't match size given in call, got none") 200 return 201 } 202 } 203 204 func searchGoroutine(t *testing.T, l *Conn, results chan *SearchResult, i int) { 205 searchRequest := NewSearchRequest( 206 baseDN, 207 ScopeWholeSubtree, DerefAlways, 0, 0, false, 208 filter[i], 209 attributes, 210 nil) 211 sr, err := l.Search(searchRequest) 212 if err != nil { 213 t.Errorf(err.Error()) 214 results <- nil 215 return 216 } 217 results <- sr 218 } 219 220 func testMultiGoroutineSearch(t *testing.T, TLS bool, startTLS bool) { 221 fmt.Printf("TestMultiGoroutineSearch: starting...\n") 222 var l *Conn 223 var err error 224 if TLS { 225 l, err = DialTLS("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapTLSPort), &tls.Config{InsecureSkipVerify: true}) 226 if err != nil { 227 t.Errorf(err.Error()) 228 return 229 } 230 defer l.Close() 231 } else { 232 l, err = Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 233 if err != nil { 234 t.Errorf(err.Error()) 235 return 236 } 237 if startTLS { 238 fmt.Printf("TestMultiGoroutineSearch: using StartTLS...\n") 239 err := l.StartTLS(&tls.Config{InsecureSkipVerify: true}) 240 if err != nil { 241 t.Errorf(err.Error()) 242 return 243 } 244 245 } 246 } 247 248 results := make([]chan *SearchResult, len(filter)) 249 for i := range filter { 250 results[i] = make(chan *SearchResult) 251 go searchGoroutine(t, l, results[i], i) 252 } 253 for i := range filter { 254 sr := <-results[i] 255 if sr == nil { 256 t.Errorf("Did not receive results from goroutine for %q", filter[i]) 257 } else { 258 fmt.Printf("TestMultiGoroutineSearch(%d): %s -> num of entries = %d\n", i, filter[i], len(sr.Entries)) 259 } 260 } 261 } 262 263 func TestMultiGoroutineSearch(t *testing.T) { 264 testMultiGoroutineSearch(t, false, false) 265 testMultiGoroutineSearch(t, true, true) 266 testMultiGoroutineSearch(t, false, true) 267 } 268 269 func TestEscapeFilter(t *testing.T) { 270 if got, want := EscapeFilter("a\x00b(c)d*e\\f"), `a\00b\28c\29d\2ae\5cf`; got != want { 271 t.Errorf("Got %s, expected %s", want, got) 272 } 273 if got, want := EscapeFilter("Lučić"), `Lu\c4\8di\c4\87`; got != want { 274 t.Errorf("Got %s, expected %s", want, got) 275 } 276 } 277 278 func TestCompare(t *testing.T) { 279 fmt.Printf("TestCompare: starting...\n") 280 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 281 if err != nil { 282 t.Fatal(err.Error()) 283 } 284 defer l.Close() 285 286 dn := "cn=math mich,ou=User Groups,ou=Groups,dc=umich,dc=edu" 287 attribute := "cn" 288 value := "math mich" 289 290 sr, err := l.Compare(dn, attribute, value) 291 if err != nil { 292 t.Errorf(err.Error()) 293 return 294 } 295 296 fmt.Printf("TestCompare: -> %v\n", sr) 297 } 298 299 func TestMatchDNError(t *testing.T) { 300 fmt.Printf("TestMatchDNError: starting..\n") 301 302 l, err := Dial("tcp", fmt.Sprintf("%s:%d", ldapServer, ldapPort)) 303 if err != nil { 304 t.Fatal(err.Error()) 305 } 306 defer l.Close() 307 308 wrongBase := "ou=roups,dc=umich,dc=edu" 309 310 searchRequest := NewSearchRequest( 311 wrongBase, 312 ScopeWholeSubtree, DerefAlways, 0, 0, false, 313 filter[0], 314 attributes, 315 nil) 316 317 _, err = l.Search(searchRequest) 318 319 if err == nil { 320 t.Errorf("Expected Error, got nil") 321 return 322 } 323 324 fmt.Printf("TestMatchDNError: err: %s\n", err.Error()) 325 326 }