vendor/github.com/go-kit/kit/sd/zk/client_test.go

   1 package zk
   2
   3 import (
   4         "bytes"
   5         "testing"
   6         "time"
   7
   8         stdzk "github.com/samuel/go-zookeeper/zk"
   9
  10         "github.com/go-kit/kit/log"
  11 )
  12
  13 func TestNewClient(t *testing.T) {
  14         var (
  15                 acl            = stdzk.WorldACL(stdzk.PermRead)
  16                 connectTimeout = 3 * time.Second
  17                 sessionTimeout = 20 * time.Second
  18                 payload        = [][]byte{[]byte("Payload"), []byte("Test")}
  19         )
  20
  21         c, err := NewClient(
  22                 []string{"FailThisInvalidHost!!!"},
  23                 log.NewNopLogger(),
  24         )
  25         if err == nil {
  26                 t.Errorf("expected error, got nil")
  27         }
  28
  29         hasFired := false
  30         calledEventHandler := make(chan struct{})
  31         eventHandler := func(event stdzk.Event) {
  32                 if !hasFired {
  33                         // test is successful if this function has fired at least once
  34                         hasFired = true
  35                         close(calledEventHandler)
  36                 }
  37         }
  38
  39         c, err = NewClient(
  40                 []string{"localhost"},
  41                 log.NewNopLogger(),
  42                 ACL(acl),
  43                 ConnectTimeout(connectTimeout),
  44                 SessionTimeout(sessionTimeout),
  45                 Payload(payload),
  46                 EventHandler(eventHandler),
  47         )
  48         if err != nil {
  49                 t.Fatal(err)
  50         }
  51         defer c.Stop()
  52
  53         clientImpl, ok := c.(*client)
  54         if !ok {
  55                 t.Fatal("retrieved incorrect Client implementation")
  56         }
  57         if want, have := acl, clientImpl.acl; want[0] != have[0] {
  58                 t.Errorf("want %+v, have %+v", want, have)
  59         }
  60         if want, have := connectTimeout, clientImpl.connectTimeout; want != have {
  61                 t.Errorf("want %d, have %d", want, have)
  62         }
  63         if want, have := sessionTimeout, clientImpl.sessionTimeout; want != have {
  64                 t.Errorf("want %d, have %d", want, have)
  65         }
  66         if want, have := payload, clientImpl.rootNodePayload; bytes.Compare(want[0], have[0]) != 0 || bytes.Compare(want[1], have[1]) != 0 {
  67                 t.Errorf("want %s, have %s", want, have)
  68         }
  69
  70         select {
  71         case <-calledEventHandler:
  72         case <-time.After(100 * time.Millisecond):
  73                 t.Errorf("event handler never called")
  74         }
  75 }
  76
  77 func TestOptions(t *testing.T) {
  78         _, err := NewClient([]string{"localhost"}, log.NewNopLogger(), Credentials("valid", "credentials"))
  79         if err != nil && err != stdzk.ErrNoServer {
  80                 t.Errorf("unexpected error: %v", err)
  81         }
  82
  83         _, err = NewClient([]string{"localhost"}, log.NewNopLogger(), Credentials("nopass", ""))
  84         if want, have := err, ErrInvalidCredentials; want != have {
  85                 t.Errorf("want %v, have %v", want, have)
  86         }
  87
  88         _, err = NewClient([]string{"localhost"}, log.NewNopLogger(), ConnectTimeout(0))
  89         if err == nil {
  90                 t.Errorf("expected connect timeout error")
  91         }
  92
  93         _, err = NewClient([]string{"localhost"}, log.NewNopLogger(), SessionTimeout(0))
  94         if err == nil {
  95                 t.Errorf("expected connect timeout error")
  96         }
  97 }
  98
  99 func TestCreateParentNodes(t *testing.T) {
 100         payload := [][]byte{[]byte("Payload"), []byte("Test")}
 101
 102         c, err := NewClient([]string{"localhost:65500"}, log.NewNopLogger())
 103         if err != nil {
 104                 t.Errorf("unexpected error: %v", err)
 105         }
 106         if c == nil {
 107                 t.Fatal("expected new Client, got nil")
 108         }
 109
 110         s, err := NewInstancer(c, "/validpath", log.NewNopLogger())
 111         if err != stdzk.ErrNoServer {
 112                 t.Errorf("unexpected error: %v", err)
 113         }
 114         if s != nil {
 115                 t.Error("expected failed new Instancer")
 116         }
 117
 118         s, err = NewInstancer(c, "invalidpath", log.NewNopLogger())
 119         if err != stdzk.ErrInvalidPath {
 120                 t.Errorf("unexpected error: %v", err)
 121         }
 122         _, _, err = c.GetEntries("/validpath")
 123         if err != stdzk.ErrNoServer {
 124                 t.Errorf("unexpected error: %v", err)
 125         }
 126
 127         c.Stop()
 128
 129         err = c.CreateParentNodes("/validpath")
 130         if err != ErrClientClosed {
 131                 t.Errorf("unexpected error: %v", err)
 132         }
 133
 134         s, err = NewInstancer(c, "/validpath", log.NewNopLogger())
 135         if err != ErrClientClosed {
 136                 t.Errorf("unexpected error: %v", err)
 137         }
 138         if s != nil {
 139                 t.Error("expected failed new Instancer")
 140         }
 141
 142         c, err = NewClient([]string{"localhost:65500"}, log.NewNopLogger(), Payload(payload))
 143         if err != nil {
 144                 t.Errorf("unexpected error: %v", err)
 145         }
 146         if c == nil {
 147                 t.Fatal("expected new Client, got nil")
 148         }
 149
 150         s, err = NewInstancer(c, "/validpath", log.NewNopLogger())
 151         if err != stdzk.ErrNoServer {
 152                 t.Errorf("unexpected error: %v", err)
 153         }
 154         if s != nil {
 155                 t.Error("expected failed new Instancer")
 156         }
 157 }